!/usr/bin/env bash

add any rocks required for ci_tests to this list lua-curl depends on a libcurl development package (i.e. libcurl4-openssl-dev)

!/usr/bin/env bash

!/usr/bin/env bash

fetch and unpack lua src

civetweb base dir

-L because it's a 302 redirect

this script installs a lua / luarocks environment in .travis/lua this is necessary because travis docker architecture (the fast way) does not permit sudo, and does not contain a useful lua installation

build luarocks

After this script is finished, you can configure your environment to use it by sourcing lua_env.sh

The current versions when this script was written

!/usr/bin/env /bash

fetch and unpack luarocks

add to path required by luarocks installer

directory where this script is located

mv built lua install to target Lua dir

build lua

Allocate new message. Caller must hold the lock.

If client is too far behind, return all messages.

We have a message to store. Write-lock the ringbuffer, grab the next message and copy data into it.

A handler for the /ajax/send_message endpoint.

Initialize random number generator. It will be used later on for the session identifier creation.

vim:ts=2:sw=2:et

Protects messages, sessions, last_message_id

Get session object for the connection. Caller must hold the lock.

This file is part of the Civetweb project, http://code.google.com/p/civetweb It implements an online chat server. For more details, see the documentation on the project web site. To test the application, 1. type "make" in the directory where this file lives 2. point your browser to http://127.0.0.1:8081

Redirect user to the login form. In the cookie, store the original URL we came from, so that after the authorization we could redirect back.

In production environment we should ask an authentication system to authenticate the user. Here however we do trivial check that user and password are not empty

Authentication failure, redirect to login.

No suitable handler found, mark as not processed. Civetweb will try to serve the request.

A handler for the /authorize endpoint. Login page form sends user name and password to this endpoint.

Generate session ID. buf must be 33 bytes in size. Note that it is easy to steal session cookies by sniffing traffic. This is why all communication must be SSL-ed.

buf is allocated on stack and hopefully is large enough to hold all messages (it may be too small if the ringbuffer is full and all messages are large. in this case asserts will trigger).

Setup and start Civetweb

Allocate new session object

If "callback" param is present in query string, this is JSONP call. Return 1 in this case, or 0 if "callback" is not specified. Wrap an output in Javascript function call.

Fetch user name and password.

Describes single message sent to a chat. If user is empty (0 length), the message is then originated from the server itself.

Session ID Set user, needed by Javascript code Delete original_url

Return 1 if request is authorized, 0 otherwise.

Get a get of messages with IDs greater than last_id and transform them into a JSON string. Return that string to the caller. The string is dynamically allocated, caller must free it. If there are no messages, NULL is returned.

Message ID User that have sent the message Message text Message timestamp, UTC

Large enough to hold all messages

Authentication success: 1. create new session 2. set session ID token in the cookie 3. remove original_url from the cookie - not needed anymore 4. redirect client back to the original URL The most secure way is to stay HTTPS all the time. However, just to show the technique, we redirect to HTTP after the successful authentication. The danger of doing this is that session cookie can be stolen and an attacker may impersonate the user. Secure application must use HTTPS all the time.

Ringbuffer for messages Current sessions

Empty user indicates server message

Session ID, must be unique Random data used for extra user validation Authenticated user Expiration timestamp, UTC

Always authorize accesses to login page and to authorize URI

Read-lock the ringbuffer. Loop over all messages, making a JSON string.

A handler for the /ajax/get_messages endpoint. Return a list of messages with ID greater than requested.

Wait until enter is pressed, then exit

Return 1 if username/password is allowed, 0 otherwise.

Describes web session.

This file is part of the Civetweb project, http://sourceforge.net/projects/civetweb/

sourceforge.net/projects/civetweb/ -->

"}},lastModified:{},etag:{},ajax:function(a){function b(){e.success&& e.success.call(k,o,i,x);e.global&&f("ajaxSuccess",[x,e])}function d(){e.complete&&e.complete.call(k,x,i);e.global&&f("ajaxComplete",[x,e]);e.global&&!--c.active&&c.event.trigger("ajaxStop")}function f(q,p){(e.context?c(e.context):c.event).trigger(q,p)}var e=c.extend(true,{},c.ajaxSettings,a),j,i,o,k=a&&a.context||e,n=e.type.toUpperCase();if(e.data&&e.processData&&typeof e.data!=="string")e.data=c.param(e.data,e.traditional);if(e.dataType==="jsonp"){if(n==="GET")N.test(e.url)||(e.url+=(ka.test(e.url)? "&":"?")+(e.jsonp||"callback")+"=?");else if(!e.data||!N.test(e.data))e.data=(e.data?e.data+"&":"")+(e.jsonp||"callback")+"=?";e.dataType="json"}if(e.dataType==="json"&&(e.data&&N.test(e.data)||N.test(e.url))){j=e.jsonpCallback||"jsonp"+sb++;if(e.data)e.data=(e.data+"").replace(N,"="+j+"$1");e.url=e.url.replace(N,"="+j+"$1");e.dataType="script";A[j]=A[j]||function(q){o=q;b();d();A[j]=w;try{delete A[j]}catch(p){}z&&z.removeChild(C)}}if(e.dataType==="script"&&e.cache===null)e.cache=false;if(e.cache=== false&&n==="GET"){var r=J(),u=e.url.replace(wb,"$1_="+r+"$2");e.url=u+(u===e.url?(ka.test(e.url)?"&":"?")+"_="+r:"")}if(e.data&&n==="GET")e.url+=(ka.test(e.url)?"&":"?")+e.data;e.global&&!c.active++&&c.event.trigger("ajaxStart");r=(r=xb.exec(e.url))&&(r[1]&&r[1]!==location.protocol||r[2]!==location.host);if(e.dataType==="script"&&n==="GET"&&r){var z=s.getElementsByTagName("head")[0]||s.documentElement,C=s.createElement("script");C.src=e.url;if(e.scriptCharset)C.charset=e.scriptCharset;if(!j){var B= false;C.onload=C.onreadystatechange=function(){if(!B&&(!this.readyState||this.readyState==="loaded"||this.readyState==="complete")){B=true;b();d();C.onload=C.onreadystatechange=null;z&&C.parentNode&&z.removeChild(C)}}}z.insertBefore(C,z.firstChild);return w}var E=false,x=e.xhr();if(x){e.username?x.open(n,e.url,e.async,e.username,e.password):x.open(n,e.url,e.async);try{if(e.data||a&&a.contentType)x.setRequestHeader("Content-Type",e.contentType);if(e.ifModified){c.lastModified[e.url]&&x.setRequestHeader("If-Modified-Since", c.lastModified[e.url]);c.etag[e.url]&&x.setRequestHeader("If-None-Match",c.etag[e.url])}r||x.setRequestHeader("X-Requested-With","XMLHttpRequest");x.setRequestHeader("Accept",e.dataType&&e.accepts[e.dataType]?e.accepts[e.dataType]+",

! * jQuery JavaScript Library v1.4.2 * http://jquery.com/ * * Copyright 2010, John Resig * Dual licensed under the MIT or GPL Version 2 licenses. * http://jquery.org/license * * Includes Sizzle.js * http://sizzlejs.com/ * Copyright 2010, The Dojo Foundation * Released under the MIT, BSD, and GPL Licenses. * * Date: Sat Feb 13 22:33:48 2010 -0500

This file is part of the Civetweb project, http://sourceforge.net/projects/civetweb/

sourceforge.net/projects/civetweb/ -->

Set correct action for the login form. We assume that the SSL port is the next one to insecure one.

Note that this page is self-sufficient, it does not load any other CSS or Javascript file. This is done so because only this page is allowed for non-authorized users. If we want to load other files from the frontend, we need to change backend code to allow those for non-authorized users. See chat.c :: must_authorize() function.

Keep only chat.maxVisibleMessages, delete older ones.

This file is part of Civetweb project, http://sourceforge.net/projects/civetweb/

Backend URL, string. 'http://backend.address.com' or '' if backend is the same as frontend

vim:ts=2:sw=2:et

Deselect menu buttons Select clicked button Hide all main windows Show main window

input.disabled = true;

Stop the server.

Always set Content-Length

Wait until user hits "enter". Server is running in separate thread. Navigating to http://localhost:8080 will invoke begin_request_handler().

Send HTTP reply to the client

Start the web server.

List of options. Last element must be NULL.

Returning non-zero tells civetweb that our function has replied to the client, and civetweb should not send client any more data.

Prepare the message we're going to send

This function will be called by civetweb on every new request.

Prepare callbacks structure. We have only one callback, the rest are NULL.

User has submitted a form, show submitted data and a variable value

Parse form data. input1 and input2 are guaranteed to be NUL-terminated

Show HTML form.

Mark request as processed

Wait until user hits "enter"

Send reply to the client, showing submitted form values.

Copyright (c) 2014 the Civetweb developers * Copyright (c) 2004-2012 Sergey Lyubka * This file is a part of civetweb project, http://github.com/bel2125/civetweb

callback: called after uploading a file is completed

Startup options for the server

Test server will use this port

Display a welcome message

Start the server

This example is deprecated and no longer maintained. * All relevant parts have been merged into the embedded_c example.

!_WIN32

See http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.1

Mark request as processed

Wait until thr user hits "enter", then stop the server

Main program: Set callbacks and start the server.

callback: used to generate all content

enctype="multipart/form-data"

Show HTML form.

close websock

chat message

init command

This example uses deprecated interfaces: global websocket callbacks. They have been superseeded by URI specific callbacks. See examples/embedded_c for an up to date example.

keep alive

var connection; var keepAlive = false; function webSockKeepAlive() { if (keepAlive) { connection.send('ping'); // Send the message 'ping' to the server setTimeout("webSockKeepAlive()", 10000); } } function load() { connection = new WebSocket("ws://127.0.0.1/MyWebSock"); connection.onopen = function () { var send = "init " + Math.round(Math.random()*4294967294+1); console.log('Client: ' + send); connection.send(send); keepAlive = true; webSockKeepAlive(); }; connection.onerror = function (error) { keepAlive = false; connection.close(); console.log('WebSocket error: ' + error); alert("WebSocket error"); }; connection.onmessage = function (e) { console.log('Server: ' + e.data); if (e.data.substring(0,5) == "title") {window.document.title = e.data.substring(6);} else if (e.data.substring(0,3) == "msg") { var msgStr = document.getElementById('msg'); msgStr.innerHTML = msgStr.innerHTML + e.data.substring(4); } }; } //

document_root: The path to the test function websock.htm

if the port is changed here, it needs to be changed in websock.htm as well

This example uses deprecated interfaces: global websocket callbacks. They have been superseeded by URI specific callbacks. See examples/embedded_c for an up to date example.

port: use http standard to match websocket url in websock.htm: ws://127.0.0.1/MyWebSock

return 0 to accept every connection

WEBSOCKET SERVER

Should get the acknowledge message

strlen(websocket_acknowledge_msg)

Connect client 3

* Copyright (c) 2014-2016 the Civetweb developers * Copyright (c) 2014 Jordan Shelley * https://github.com/jshelley * License http://opensource.org/licenses/mit-license.php MIT License

First set up a websocket server

Won't get any message

Simple example program on how to use websocket client embedded C interface.

Send websocket welcome message

Client 3 should get the websocket welcome message

New interface:

Obsolete:

Send websocket acknowledge message

Can not send a websocket goodbye message here - the connection is already * closed

return 1 to keep the connetion open

strlen(websocket_goodbye_msg)

Should get the websocket welcome message

***********************************************************************************

This example is superseeded by other examples, and no longer * actively maintained. * See examples/embedded_c for an up to date example.

Now connect a second client

Should get the goodbye message

WEBSOCKET CLIENT

Then connect a first client

strlen(websocket_welcome_msg)

Client 2 should get the websocket welcome message

check for websocket support for Internet Explorer < 10 there are options for websocket support that could be integrated into production code, but for now, we are expecting browser support to be present for this demo

websocket connection

user connect/disconnect

Can be anything

user turn updates on/off

css-tricks.com/css3-progress-bars/

time to close the connection

simple structure for keeping track of websocket connection

second meter 0 to 500, by 10 every 0.5 second

Wait until user hits "enter"

echo back

get simple greeting for the web server

we should not send addional messages when close requested/acknowledged

websocket_ready_handler() Once websocket negotiation is complete, start a server for the connection

websocket_close_handler() When websocket is closed, tell the associated server to shut down

Arguments: flags: first byte of websocket frame, see websocket RFC, http://tools.ietf.org/html/rfc6455, section 5.2 data, data_len: payload data. Mask, if any, is already applied.

end of list

third meter 0 to 100, by 10 every 1.0 second

up to 16 independent client connections

turn on updates

client sent PING, respond with PONG

first meter 0 to 1000, by 5 every 0.1 second

keep connection open

** interpret data as commands here **

0.1 seconds

fprintf(stderr, "close handler\n"); /* called for every close, not just websockets */

Send initial meter updates

time base and structure periodic updates to client for demo

received PONG to our PING, no action

show the greeting and some basic information

if we are closing, server should not send new data

Send meter updates

ws_server_thread() Simple demo server thread. Sends periodic updates to connected clients

Copyright (c) 2004-2012 Sergey Lyubka This file is a part of civetweb project, http://github.com/bel2125/civetweb v 0.1 Contributed by William Greathouse 9-Sep-2013

0.1 second

Send periodic PING to assure websocket remains connected, except if we are closing

While the connection is open, send periodic updates

websocket_connect_handler() On new client connection, find next available server connection and store new connection information. If no more server connections are available tell civetweb to not accept the client request.

If client initiated close, respond with close message in acknowlegement

turn off updates

Add handler for all files with .foo extention

Add handler for /close extention

Call the form handler

Handler may access the request info using mg_get_request_info

Add handler for /A* and special handler for /A/B

Add HTTP site to open a websocket connection

Add handler for /form (serve a file outside the document root)

We know the content length in advance

* Copyright (c) 2013-2017 the CivetWeb developers * Copyright (c) 2013 No Face Press, LLC * License http://opensource.org/licenses/mit-license.php MIT License

example from https://github.com/civetweb/civetweb/issues/347

mg_printf(conn, "<script type=\"text/javascript\"><![CDATA[\n"); ... * xhtml style

Check return value:

Stop the server

We must read until we find the end (chunked encoding * or connection close), indicated my mg_read returning 0

Add HTTP site with auth

Set a random password (4 digit number - bad idea from a security * point of view, but this is an API demo, not a security tutorial), * and store it in some directory within the document root (extremely * bad idea, but this is still not a security tutorial). * The reason we create a new password every time the server starts * is just for demonstration - we don't want the browser to store the * password, so when we repeat the test we start with a new password.

No valid authorization

Visual Studio 2010+ support llu

Add handler for /postresponse example

Simple example program on how to use CivetWeb embedded into a C program.

List all listening ports

Start CivetWeb web server

Add application specific SSL initialization

Add handler EXAMPLE_URI, to explain the example

Add handler for form data

IPv4

Wait until the server should be closed

Send error

Add handler for /B, /B/A, /B/B but not for /B*

WS site for the websocket connection

In this handler, we ignore the req_info and send the file "fileName".

Check if libcivetweb has been built with all required features.

Add a file upload handler for parsing files on the fly

It would be possible to check the request info here before calling * mg_handle_form_request.

IPv6

Add handler for /cookie example

Just tell the user the new password generated for this test.

Windows will not work with path > 260 (MAX_PATH), unless we use * the unicode API. However, this is just an example code: A real * code will probably never store anything to D:\\somewhere and * must be adapted to the specific needs anyhow.

Handler may access the request info using mg_get_request_info

Simple example program on how to use Embedded C++ interface.

This handler will handle "everything else", including * requests to files. If this handler is installed, * NO_FILES should be set.

Copyright (c) 2013-2017 the Civetweb developers * Copyright (c) 2013 No Face Press, LLC * License http://opensource.org/licenses/mit-license.php MIT License

mg_printf(conn, "<script type=\"text/javascript\"><![CDATA[\n"); ... * xhtml style

CivetServer server(options); // <-- C style start <-- C++ style start

* * getParam(const char *, size_t, const char *, std::string &, size_t) * * Returns a query paramter contained in the supplied buffer. The * occurance value is a zero-based index of a particular key name. This * should not be confused with the index over all of the keys. * * @param data the - query string (text) * @param data_len - length of the query string * @param name - the key to search for * @param dst - the destination string * @param occurrence - the occurrence of the selected name in the query (0 *based). * @return true if key was found

* * removeWebSocketHandler(const std::string &) * * Removes a web socket handler. * * @param uri - the exact URL used in addWebSocketHandler().

* * Stores the user provided close handler

* * Basic interface for a URI request handler. Handlers implementations * must be reentrant.

* * Callback method for GET request. * * @param server - the calling server * @param conn - the connection information * @returns true if implemented, false otherwise

* * Callback method for authorization requests. It is up the this handler * to generate 401 responses if authorization fails. * * @param server - the calling server * @param conn - the connection information * @returns true if authorization succeeded, false otherwise

* * urlEncode(const char *, size_t, std::string &, bool) * * @param src - buffer to be encoded (0 terminated) * @param dst - destination string * @param append - true if string should not be cleared before encoding.

* * urlEncode(const char *, size_t, std::string &, bool) * * @param src - buffer to be encoded * @param src_len - length of buffer to be decoded * @param dst - destination string * @param append - true if string should not be cleared before encoding.

* * authHandler(struct mg_connection *, void *cbdata) * * Handles the authorization requests. * * @param conn - the connection information * @param cbdata - pointer to the CivetAuthHandler instance. * @returns 1 if authorized, 0 otherwise

* * closeHandler(struct mg_connection *) * * Handles closing a request (internal handler) * * @param conn - the connection information

* * urlDecode(const std::string &, std::string &, bool) * * @param src - string to be decoded * @param dst - destination string * @param is_form_url_encoded - true if form url encoded * form-url-encoded data differs from URI encoding in a way that it * uses '+' as character for space, see RFC 1866 section 8.2.1 * http://ftp.ics.uci.edu/pub/ietf/html/rfc1866.txt

* * getContext() * * @return the context or 0 if not running.

forward declaration

* * getListeningPorts() * * Returns a list of ports that are listening * * @return A vector of ports

* * getParam(struct mg_connection *conn, const char *, std::string &, size_t) * * Returns a query paramter contained in the supplied buffer. The * occurance value is a zero-based index of a particular key name. This * should not be confused with the index over all of the keys. Note that *this * function assumes that parameters are sent as text in http query string * format, which is the default for web forms. This function will work for * html forms with method="GET" and method="POST" attributes. In other *cases, * you may use a getParam version that directly takes the data instead of *the * connection as a first argument. * * @param conn - parameters are read from the data sent through this *connection * @param name - the key to search for * @param dst - the destination string * @param occurrence - the occurrence of the selected name in the query (0 *based). * @return true if key was found

* * Callback method for when websocket handshake is successfully completed, *and connection is ready for data exchange. * * @param server - the calling server * @param conn - the connection information

* * urlDecode(const char *, std::string &, bool) * * @param src - buffer to be decoded (0 terminated) * @param dst - destination string * @param is_form_url_encoded true - if form url encoded * form-url-encoded data differs from URI encoding in a way that it * uses '+' as character for space, see RFC 1866 section 8.2.1 * http://ftp.ics.uci.edu/pub/ietf/html/rfc1866.txt

* * urlEncode(const std::string &, std::string &, bool) * * @param src - buffer to be encoded * @param dst - destination string * @param append - true if string should not be cleared before encoding.

* * getParam(const std::string &, const char *, std::string &, size_t) * * Returns a query paramter contained in the supplied buffer. The * occurance value is a zero-based index of a particular key name. This * should not be confused with the index over all of the keys. * * @param data - the query string (text) * @param name - the key to search for * @param dst - the destination string * @param occurrence - the occurrence of the selected name in the query (0 *based). * @return true if key was found

* * CivetServer * * Basic class for embedded web server. This has an URL mapping built-in.

* * urlDecode(const char *, size_t, std::string &, bool) * * @param src - buffer to be decoded * @param src_len - length of buffer to be decoded * @param dst - destination string * @param is_form_url_encoded - true if form url encoded * form-url-encoded data differs from URI encoding in a way that it * uses '+' as character for space, see RFC 1866 section 8.2.1 * http://ftp.ics.uci.edu/pub/ietf/html/rfc1866.txt

* * Callback method for HEAD request. * * @param server - the calling server * @param conn - the connection information * @returns true if implemented, false otherwise

* * Callback method for POST request. * * @param server - the calling server * @param conn - the connection information * @returns true if implemented, false otherwise

_CIVETWEB_SERVER_H_

* * Callback method for when a data frame has been received from the client. * * @param server - the calling server * @param conn - the connection information * @bits: first byte of the websocket frame, see websocket RFC at *http://tools.ietf.org/html/rfc6455, section 5.2 * @data, data_len: payload, with mask (if any) already applied. * @returns true to keep socket open, false to close it

* * Callback method for when the connection is closed. * * @param server - the calling server * @param conn - the connection information

* * removeAuthHandler(const std::string &) * * Removes an authorization handler. * * @param uri - the exact URL used in addAuthHandler().

* * getHeader(struct mg_connection *conn, const std::string &headerName) * @param conn - the connection information * @param headerName - header name to get the value from * @returns a char array whcih contains the header value as string

Copyright (c) 2013-2017 the Civetweb developers * Copyright (c) 2013 No Face Press, LLC * * License http://opensource.org/licenses/mit-license.php MIT License

* * addHandler(const std::string &, CivetHandler *) * * Adds a URI handler. If there is existing URI handler, it will * be replaced with this one. * * URI's are ordered and prefix (REST) URI's are supported. * * @param uri - URI to match. * @param handler - handler instance to use.

generic user context which can be set/read, the server does nothing with this apart from keep it.

* * Callback method for PATCH request. * * @param server - the calling server * @param conn - the connection information * @returns true if implemented, false otherwise

* * addAuthHandler(const std::string &, CivetAuthHandler *) * * Adds a URI authorization handler. If there is existing URI authorization * handler, it will be replaced with this one. * * URI's are ordered and prefix (REST) URI's are supported. * * @param uri - URI to match. * @param handler - authorization handler instance to use.

* * Basic interface for a websocket handler. Handlers implementations * must be reentrant.

* * Callback method for PUT request. * * @param server - the calling server * @param conn - the connection information * @returns true if implemented, false otherwise

* * Callback method for DELETE request. * * @param server - the calling server * @param conn - the connection information * @returns true if implemented, false otherwise

* * getCookie(struct mg_connection *conn, const std::string &cookieName, *std::string &cookieValue) * * Puts the cookie value string that matches the cookie name in the *cookieValue destinaton string. * * @param conn - the connection information * @param cookieName - cookie name to get the value from * @param cookieValue - cookie value is returned using thiis reference * @returns the size of the cookie value string read.

* * Exception class for thrown exceptions within the CivetHandler object.

* * removeHandler(const std::string &) * * Removes a handler. * * @param uri - the exact URL used in addHandler().

* * Callback method for when the client intends to establish a websocket *connection, before websocket handshake. * * @param server - the calling server * @param conn - the connection information * @returns true to keep socket open, false to close it

* * requestHandler(struct mg_connection *, void *cbdata) * * Handles the incomming request. * * @param conn - the connection information * @param cbdata - pointer to the CivetHandler instance. * @returns 0 if implemented, false otherwise

* * Destructor

* * Basic interface for a URI authorization handler. Handler implementations * must be reentrant.

* * close() * * Stops server and frees resources.

* * Constructor * * This automatically starts the sever. * It is good practice to call getContext() after this in case there * were errors starting the server. * * Note: CivetServer should not be used as a static instance in a Windows * DLL, since the constructor creates threads and the destructor joins * them again (creating/joining threads should not be done in static * constructors). * * @param options - the web server options. * @param callbacks - optional web server callback methods. * * @throws CivetException

__cplusplus

* * Callback method for OPTIONS request. * * @param server - the calling server * @param conn - the connection information * @returns true if implemented, false otherwise

* * addWebSocketHandler * * Adds a WebSocket handler for a specific URI. If there is existing URI *handler, it will * be replaced with this one. * * URI's are ordered and prefix (REST) URI's are supported. * * @param uri - URI to match. * @param handler - handler instance to use.

* * CivetCallbacks * * wrapper for mg_callbacks

This structure may be extended in future versions.

Called when civetweb is about to log a message. If callback returns non-zero, civetweb does not log anything.

port number

Blocks until unique access is obtained to this connection. Intended for use with websockets only. Invoke this before mg_write or mg_printf when communicating with a websocket if your code has server-initiated communication as well as communication in direct response to a message.

Send contents of the entire file together with HTTP headers. Parameters: conn: Current connection information. path: Full path to the file to send. mime_type: Content-Type for file. NULL will cause the type to be looked up by the file extension. additional_headers: Additional custom header fields appended to the header. Each header should start with an X-, to ensure it is not included twice. NULL does not append anything.

URL-decoded URI (relative). Can be NULL * if the request_uri does not address a * resource at the server host.

Called when civetweb initializes SSL library. Parameters: user_data: parameter user_data passed when starting the server. Return value: 0: civetweb will set up the SSL certificate. 1: civetweb assumes the callback already set up the certificate. -1: initializing ssl fails.

Skip this field (neither get nor store it). Continue with the * next field.

Get the value of particular HTTP header. This is a helper function. It traverses request_info->http_headers array, and if the header is present in the array, returns its value. If it is not present, NULL is returned.

redirect all requests: 0 = no, 1 = yes

Called when websocket request is received, before websocket handshake. Return value: 0: civetweb proceeds with websocket handshake. 1: connection is closed immediately. This callback is deprecated: Use mg_set_websocket_handler instead.

Return information associated with the request. * Use this function to implement a server and get data about a request * from a HTTP/HTTPS client. * Note: Before CivetWeb 1.10, this function could be used to read * a response from a server, when implementing a client, although the * values were never returned in appropriate mg_request_info elements. * It is strongly advised to use mg_get_response_info for clients.

Fetch value of certain cookie variable into the destination buffer. Destination buffer is guaranteed to be '\0' - terminated. In case of failure, dst[0] == '\0'. Note that RFC allows many occurrences of the same parameter. This function returns only first occurrence. Return: On success, value length. On error: -1 (either "Cookie:" header is not present at all or the requested parameter is not found). -2 (destination buffer is NULL, zero length or too small to hold the value).

User data pointer passed to mg_start()

Macros for enabling compiler-specific checks for printf-like arguments.

Read data from the remote end, return number of bytes read. Return: 0 connection has been closed by peer. No more data could be read. < 0 read error. No more data could be read from the connection. > 0 number of bytes read into the buffer.

URL-decode input buffer into destination buffer. 0-terminate the destination buffer. form-url-encoded data differs from URI encoding in a way that it uses '+' as character for space, see RFC 1866 section 8.2.1 http://ftp.ics.uci.edu/pub/ietf/html/rfc1866.txt Return: length of the decoded data, or -1 if dst buffer is too small.

Client's port

Stop parsing this request. Skip the remaining fields.

Stop the web server. Must be called last, when an application wants to stop the web server and release all associated resources. This function blocks until all Civetweb threads are stopped. Context pointer becomes invalid.

utility methods to compare two buffers, case insensitive.

Old nomenclature.

Store body data into a file.

Return values definition for the "field_found" callback in * mg_form_data_handler.

Note: The "file in memory" feature is a deletion candidate, since * it complicates the code, and does not add any value compared to * "mg_add_request_handler". * See this discussion thread: * https://groups.google.com/forum/#!topic/civetweb/h9HT4CmeYqI * If you disagree, if there is any situation this is indeed useful * and cannot trivially be replaced by another existing feature, * please contribute to this discussion during the next 3 month * (till end of April 2017), otherwise this feature might be dropped * in future releases.

Get the value of particular configuration parameter. The value returned is read-only. Civetweb does not allow changing configuration at run time. If given parameter name is not valid, NULL is returned. For valid names, return value is guaranteed to be non-NULL. If parameter is not set, zero-length string is returned.

Old nomenclature

Called when initializing a new connection object. * Can be used to initialize the connection specific user data * (mg_request_info->conn_data, mg_get_user_connection_data). * When the callback is called, it is not yet known if a * valid HTTP(S) request will be made. * Parameters: * conn: not yet fully initialized connection object * conn_data: output parameter, set to initialize the * connection specific user data * Return value: * must be 0 * Otherwise, the result is undefined

Called when civetweb tries to open a file. Used to intercept file open calls, and serve file data from memory instead. Parameters: path: Full path to the file to open. data_len: Placeholder for the file size, if file is served from memory. Return value: NULL: do not serve file from memory, proceed with normal file open. non-NULL: pointer to the file contents in memory. data_len must be initialized with the size of the memory block.

Check which features where set when the civetweb library has been compiled. The function explicitly addresses compile time defines used when building the library - it does not mean, the feature has been initialized using a mg_init_library call. mg_check_feature can be called anytime, even before mg_init_library has been called. Parameters: feature: specifies which feature should be checked The value is a bit mask. The individual bits are defined as: 1 serve files (NO_FILES not set) 2 support HTTPS (NO_SSL not set) 4 support CGI (NO_CGI not set) 8 support IPv6 (USE_IPV6 set) 16 support WebSocket (USE_WEBSOCKET set) 32 support Lua scripts and Lua server pages (USE_LUA is set) 64 support server side JavaScript (USE_DUKTAPE is set) 128 support caching (NO_CACHING not set) 256 support server statistics (USE_SERVER_STATS is set) The result is undefined, if bits are set that do not represent a defined feature (currently: feature >= 512). The result is undefined, if no bit is set (feature == 0). Return: If feature is available, the corresponding bit is set If feature is not available, the bit is 0

Get a value of particular form variable. Parameters: data: pointer to form-uri-encoded buffer. This could be either POST data, or request_info.query_string. data_len: length of the encoded data. var_name: variable name to decode from the buffer dst: destination buffer for the decoded variable dst_len: length of the destination buffer Return: On success, length of the decoded variable. On error: -1 (variable not found). -2 (destination buffer is NULL, zero length or too small to hold the decoded variable). Destination buffer is guaranteed to be '\0' - terminated if it is not NULL or zero length.

Return builtin mime type for the given file name. For unrecognized extensions, "text/plain" is returned.

mg_set_websocket_handler Set or remove handler functions for websocket connections. This function works similar to mg_set_request_handler - see there.

Handle for the individual connection

This structure contains callback functions for handling form fields. It is used as an argument to mg_handle_form_request.

Called when civetweb is about to log access. If callback returns non-zero, civetweb does not log anything.

Connect to a websocket as a client Parameters: host: host to connect to, i.e. "echo.websocket.org" or "192.168.1.1" or "localhost" port: server port use_ssl: make a secure connection to server error_buffer, error_buffer_size: buffer for an error message path: server path you are trying to connect to, i.e. if connection to localhost/app, path should be "/app" origin: value of the Origin HTTP header data_func: callback that should be used when data is received from the server user_data: user supplied argument Return: On success, valid mg_connection object. On error, NULL. Se error_buffer for details.

struct mg_websocket_subprotocols * * List of accepted subprotocols

Called when civetweb is about to serve Lua server page, if Lua support is enabled. Parameters: lua_context: "lua_State *" pointer.

https port: 0 = no, 1 = yes

Return array of struct mg_option, representing all valid configuration options of civetweb.c. The array is terminated by a NULL name option.

Maximum number of headers

Store the field value into a file.

Download data from the remote web server. host: host name to connect to, e.g. "foo.com", or "10.12.40.1". port: port number, e.g. 80. use_ssl: wether to use SSL connection. error_buffer, error_buffer_size: error message placeholder. request_fmt,...: HTTP request. Return: On success, valid pointer to the new connection, suitable for mg_read(). On error, NULL. error_buffer contains error message. Example: char ebuf[100]; struct mg_connection *conn; conn = mg_download("google.com", 80, 0, ebuf, sizeof(ebuf), "%s", "GET / HTTP/1.0\r\nHost: google.com\r\n\r\n");

Called when data frame has been received from the client. Parameters: bits: first byte of the websocket frame, see websocket RFC at http://tools.ietf.org/html/rfc6455, section 5.2 data, data_len: payload, with mask (if any) already applied. Return value: 1: keep this websocket connection open. 0: close this websocket connection. This callback is deprecated: Use mg_set_websocket_handler instead.

Number of HTTP headers

Get user data passed to mg_start from context.

This structure needs to be passed to mg_start(), to let civetweb know which callbacks to invoke. For a detailed description, see https://github.com/civetweb/civetweb/blob/master/docs/UserManual.md

Deprecated: Use mg_get_valid_options instead.

Send data to a websocket server wrapped in a masked websocket frame. Uses mg_lock_connection to ensure that the transmission is not interrupted, i.e., when the application is proactively communicating and responding to a request simultaneously. Send data to a websocket server wrapped in a masked websocket frame. This function is available when civetweb is compiled with -DUSE_WEBSOCKET Return: 0 when the connection has been closed -1 on error >0 number of bytes written on success

CIVETWEB_HEADER_INCLUDED

Called when civetweb has received new HTTP request. If the callback returns one, it must process the request by sending valid HTTP headers and a body. Civetweb will not do any further processing. Otherwise it must return zero. Note that since V1.7 the "begin_request" function is called before an authorization check. If an authorization check is required, use a request_handler instead. Return value: 0: civetweb will process the request itself. In this case, the callback must not send any data to the client. 1-999: callback already processed the request. Civetweb will not send any data after the callback returned. The return code is stored as a HTTP status code for the access log.

Get a formatted link corresponding to the current request Parameters: conn: current connection information. buf: string buffer (out) buflen: length of the string buffer Returns: <0: error >=0: ok

Called when civetweb has uploaded a file to a temporary directory as a result of mg_upload() call. Note that mg_upload is deprecated. Use mg_handle_form_request instead. Parameters: file_name: full path name to the uploaded file.

Send contents of the entire file together with HTTP headers. * Parameters: * conn: Current connection handle. * path: Full path to the file to send. * mime_type: Content-Type for file. NULL will cause the type to be * looked up by the file extension.

HTTP header value

Called when civetweb is closing a connection. The per-context mutex is locked when this is invoked. Websockets: Before mg_set_websocket_handler has been added, it was primarily useful for noting when a websocket is closing, and used to remove it from any application-maintained list of clients. Using this callback for websocket connections is deprecated: Use mg_set_websocket_handler instead. Connection specific data: If memory has been allocated for the connection specific user data (mg_request_info->conn_data, mg_get_user_connection_data), this is the last chance to free it.

1 if SSL-ed, 0 if not

Allocate maximum headers

websocket subprotocol, * accepted during handshake

Deprecated: use local_uri instead

Convenience function -- create detached thread. Return: 0 on success, non-0 on error.

MG_LEGACY_INTERFACE

Callback types for websocket handlers in C/C++. mg_websocket_connect_handler Is called when the client intends to establish a websocket connection, before websocket handshake. Return value: 0: civetweb proceeds with websocket handshake. 1: connection is closed immediately. mg_websocket_ready_handler Is called when websocket handshake is successfully completed, and connection is ready for data exchange. mg_websocket_data_handler Is called when a data frame has been received from the client. Parameters: bits: first byte of the websocket frame, see websocket RFC at http://tools.ietf.org/html/rfc6455, section 5.2 data, data_len: payload, with mask (if any) already applied. Return value: 1: keep this websocket connection open. 0: close this websocket connection. mg_connection_close_handler Is called, when the connection is closed.

mg_request_handler Called when a new request comes in. This callback is URI based and configured with mg_set_request_handler(). Parameters: conn: current connection information. cbdata: the callback data configured with mg_set_request_handler(). Returns: 0: the handler could not handle the request, so fall through. 1 - 999: the handler processed the request. The return code is stored as a HTTP status code for the access log.

Get context information. Useful for server diagnosis. Parameters: ctx: Context handle buffer: Store context information here. buflen: Length of buffer (including a byte required for a terminating 0). Return: Available size of system information, exluding a terminating 0. The information is complete, if the return value is smaller than buflen. The result is a JSON formatted string, the exact content may vary. Note: It is possible to determine the required buflen, by first calling this function with buffer = NULL and buflen = NULL. The required buflen is one byte more than the returned value. However, since the available context information changes, you should allocate a few bytes more.

Get the field value.

Check if the current request has a valid authentication token set. * A file is used to provide a list of valid user names, realms and * password hashes. The file can be created and modified using the * mg_modify_passwords_file API function. * Parameters: * conn: Current connection handle. * realm: Authentication realm. If NULL is supplied, the sever domain * set in the authentication_domain configuration is used. * filename: Path and name of a file storing multiple password hashes. * Return: * > 0 Valid authentication * 0 Invalid authentication * < 0 Error (all values < 0 should be considered as invalid * authentication, future error codes will have negative * numbers) * -1 Parameter error * -2 File not found

Send contents of the entire file together with HTTP headers.

URL part after '?', not including '?', or NULL

Start web server. Parameters: callbacks: mg_callbacks structure with user-defined callbacks. options: NULL terminated list of option_name, option_value pairs that specify Civetweb configuration parameters. Side-effects: on UNIX, ignores SIGCHLD and SIGPIPE signals. If custom processing is required for these, signal handlers must be set up after calling mg_start(). Example: const char *options[] = { "document_root", "/var/www", "listening_ports", "80,443s", NULL }; struct mg_context *ctx = mg_start(&my_func, NULL, options); Refer to https://github.com/civetweb/civetweb/blob/master/docs/UserManual.md for the list of valid option and their possible values. Return: web server context, or NULL on error.

mg_set_request_handler Sets or removes a URI mapping for a request handler. This function uses mg_lock_context internally. URI's are ordered and prefixed URI's are supported. For example, consider two URIs: /a/b and /a /a matches /a /a/b matches /a/b /a/c matches /a Parameters: ctx: server context uri: the URI (exact or pattern) for the handler handler: the callback handler to use when the URI is requested. If NULL, an already registered handler for this URI will be removed. The URI used to remove a handler must match exactly the one used to register it (not only a pattern match). cbdata: the callback data to give to the handler when it is called.

Get user data set for the current connection.

Send data to the client. Return: 0 when the connection has been closed -1 on error >0 number of bytes written on success

Client's IP address. Deprecated: use remote_addr instead

Send a part of the message body, if chunked transfer encoding is set. * Only use this function after sending a complete HTTP request or response * header with "Transfer-Encoding: chunked" set.

E.g. "1.0", "1.1"

"GET", "POST", etc

Close the connection opened by mg_download().

HTTP header name

Send HTTP error reply.

User supplied argument, passed to all callback functions.

Client certificate information

Client certificate information (part of mg_request_info)

Process form data. * Returns the number of fields handled, or < 0 in case of an error. * Note: It is possible that several fields are already handled successfully * (e.g., stored into files), before the request handling is stopped with an * error. In this case a number < 0 is returned as well. * In any case, it is the duty of the caller to remove files once they are * no longer required.

New nomenclature

Return array of strings that represent valid configuration options. For each option, option name and default value is returned, i.e. the number of entries in the array equals to number_of_options x 2. Array is NULL terminated.

Get context from connection.

Return information associated with a HTTP/HTTPS response. * Use this function in a client, to check the response from * the server.

Connect to a TCP server as a client (can be used to connect to a HTTP server) Parameters: host: host to connect to, i.e. "www.wikipedia.org" or "192.168.1.1" or "localhost" port: server port use_ssl: make a secure connection to server error_buffer, error_buffer_size: buffer for an error message Return: On success, valid mg_connection object. On error, NULL. Se error_buffer for details.

Opcodes, from http://tools.ietf.org/html/rfc6455

URL-decoded URI (absolute or relative, * as in the request)

mg_set_auth_handler Sets or removes a URI mapping for an authorization handler. This function works similar to mg_set_request_handler - see there.

URL-encode input buffer into destination buffer. returns the length of the resulting buffer or -1 is the buffer is too small.

Return CivetWeb version.

Authenticated user, or NULL if no auth used

This callback function is called, if a new field has been found. * The return value of this callback is used to define how the field * should be processed. * * Parameters: * key: Name of the field ("name" property of the HTML input field). * filename: Name of a file to upload, at the client computer. * Only set for input fields of type "file", otherwise NULL. * path: Output parameter: File name (incl. path) to store the file * at the server computer. Only used if FORM_FIELD_STORAGE_STORE * is returned by this callback. Existing files will be * overwritten. * pathlen: Length of the buffer for path. * user_data: Value of the member user_data of mg_form_data_handler * * Return value: * The callback must return the intended storage for this field * (See FORM_FIELD_STORAGE_*).

Called when a new worker thread is initialized. Parameters: ctx: context handle thread_type: 0 indicates the master thread 1 indicates a worker thread handling client connections 2 indicates an internal helper thread (timer thread)

New nomenclature.

E.g. "OK"

__cplusplus

Send data to a websocket client wrapped in a websocket frame. Uses mg_lock_connection to ensure that the transmission is not interrupted, i.e., when the application is proactively communicating and responding to a request simultaneously. Send data to a websocket client wrapped in a websocket frame. This function is available when civetweb is compiled with -DUSE_WEBSOCKET Return: 0 when the connection has been closed -1 on error >0 number of bytes written on success

Called when civetweb is about to send HTTP error to the client. Implementing this callback allows to create custom error pages. Parameters: status: HTTP error status code. Return value: 1: run civetweb error handler. 0: callback already handled the error.

Copyright (c) 2013-2017 the Civetweb developers * Copyright (c) 2004-2013 Sergey Lyubka * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE.

Get information on the system. Useful for support requests. Parameters: buffer: Store system information as string here. buflen: Length of buffer (including a byte required for a terminating 0). Return: Available size of system information, exluding a terminating 0. The information is complete, if the return value is smaller than buflen. The result is a JSON formatted string, the exact content may vary. Note: It is possible to determine the required buflen, by first calling this function with buffer = NULL and buflen = NULL. The required buflen is one byte more than the returned value.

Handle for the HTTP service itself

Read entire request body and store it in a file "path". Return: < 0 Error >= 0 Number of bytes stored in file "path".

Get a value of particular form variable. Parameters: data: pointer to form-uri-encoded buffer. This could be either POST data, or request_info.query_string. data_len: length of the encoded data. var_name: variable name to decode from the buffer dst: destination buffer for the decoded variable dst_len: length of the destination buffer occurrence: which occurrence of the variable, 0 is the first, 1 the second... this makes it possible to parse a query like b=x&a=y&a=z which will have occurrence values b:0, a:0 and a:1 Return: On success, length of the decoded variable. On error: -1 (variable not found). -2 (destination buffer is NULL, zero length or too small to hold the decoded variable). Destination buffer is guaranteed to be '\0' - terminated if it is not NULL or zero length.

Length (in bytes) of the request body, can be -1 if no length was given.

mg_authorization_handler Callback function definition for mg_set_auth_handler Parameters: conn: current connection information. cbdata: the callback data configured with mg_set_request_handler(). Returns: 0: access denied 1: access granted

Called when civetweb context is deleted. Parameters: ctx: context handle

Deprecated: Use mg_get_server_ports instead.

Lock server context. This lock may be used to protect resources that are shared between different connection/worker threads.

This structure contains information about the HTTP request.

Connection-specific user data

E.g. 200

Wait for a response from the server Parameters: conn: connection ebuf, ebuf_len: error message placeholder. timeout: time to wait for a response in milliseconds (if < 0 then wait forever) Return: On success, >= 0 On error/timeout, < 0

1 = IPv4, 2 = IPv6, 3 = both

Called when civetweb has finished processing request.

Called after civetweb context has been created, before requests are processed. Parameters: ctx: context handle

File upload functionality. Each uploaded file gets saved into a temporary file and MG_UPLOAD event is sent. Return number of uploaded files. Deprecated: Use mg_handle_form_request instead.

Send HTTP digest access authentication request. * Browsers will send a user name and password in their next request, showing * an authentication dialog if the password is not stored. * Parameters: * conn: Current connection handle. * realm: Authentication realm. If NULL is supplied, the sever domain * set in the authentication_domain configuration is used. * Return: * < 0 Error

Client's IP address as a string.

Set user data for the current connection.

Get text representation of HTTP status code.

Add, edit or delete the entry in the passwords file. * * This function allows an application to manipulate .htpasswd files on the * fly by adding, deleting and changing user records. This is one of the * several ways of implementing authentication on the server side. For another, * cookie-based way please refer to the examples/chat in the source tree. * * Parameter: * passwords_file_name: Path and name of a file storing multiple passwords * realm: HTTP authentication realm (authentication domain) name * user: User name * password: * If password is not NULL, entry modified or added. * If password is NULL, entry is deleted. * * Return: * 1 on success, 0 on error.

Get the list of ports that civetweb is listening on. The parameter size is the size of the ports array in elements. The caller is responsibility to allocate the required memory. This function returns the number of struct mg_server_ports elements filled in, or <0 in case of an error.

Un-initialize this library. * Return value: * 0: error

!/bin/sh using "pass" for every password

remove last build

check if the build was successful

! /bin/sh

new scan build

pack build results for upload

check if we use the correct directory

copy files to build folder

return "ok"

data is "var1=val1&var2=val2...". Find variable first

Point s to the end of the value

No handler found, close connection

Add one extra character: in case the post-data is a text, it is required as 0-termination. Do not increment con_len, since the 0 terminating is not part of the content (text or binary).

Happens when a request hits the server before the context is saved

No handler found

Maximum cookie length as per microsoft is 4096. http://msdn.microsoft.com/en-us/library/ms178194.aspx

Decode variable into destination buffer

get requests do store html <form> field values in the http query_string

Point p to variable value

Copyright (c) 2013-2017 the Civetweb developers * Copyright (c) 2013 No Face Press, LLC * * License http://opensource.org/licenses/mit-license.php MIT License

Now update the variable index

3. call a "handle everything" callback, if registered

Asterisk

Get a random number (independent of C rand function)

range buffer is big enough

Step 1.2: Check websocket protocol version.

TODO (mid): Check the mg_send_http_error situations in this function

Calculate an estimate for the required space

assert(handler == NULL);

"Cache-Control: private\r\n" (= default)

File name is relative to the webserver working directory * or it is absolute system path

Timeout: should retry

RFC2616 Section 10.1.2

REPORT method only allowed for CGI/Lua/LSP and callbacks.

Handler for error group, e.g., 5xx error * handler * for all server errors (500-599)

RFC 6585, Section 4

Set close flag, so the server thread can exit.

Initialize port and len as invalid.

File already exists

Do not show current dir (but show hidden files as they will * also be removed)

Cannot get host from the Host: header. * Fallback to our IP address.

http://en.wikipedia.org/wiki/WebM

File is read only

Here we can either generate and send a directory listing, * or send an "access denied" error.

RFC2616 Section 10.2.3

Pointer to the beginning of the portion of the incoming websocket * message queue. * The original websocket upgrade request is never removed, so the queue * begins after it.

Loop over multiple requests sent using the same connection * (while "keep alive").

assert(s >= p);

Traverse index files list. For each entry, append it to the given * path and see if the file exists. If it exists, break the loop

Gobble initial spaces

Redirect error code from -1 to -2 (destination buffer too * small).

SSL descriptor

We are using non-blocking sockets. Thus, the * set_sock_timeout(so.sock, timeout); * call is no longer required.

Depending on the SDK, this function uses either * (volatile unsigned int *) or (volatile LONG *), * so whatever you use, the other SDK is likely to raise a warning.

This value is the last one

Bind to a specific IPv4 address, e.g. 192.168.1.5:8080

We need an additional wait loop around this, because in some cases * with TLSwe may get data from the socket but not from SSL_read. * In this case we need to repeat at least once.

queue is full

123

!NO_CGI

AUTH_HANDLER

0 = nowhere, 1 = on disk, 2 = in memory

Important: on new connection, reset the receiving buffer. Credit * goes to crule42.

success

RFC2616 Section 10.4.16

ignore leading whitespaces

Use "Cache-Control: max-age" instead of "Expires" header. * Reason: see https://www.mnot.net/blog/2007/05/15/expires_max-age

Error

100 nsecs

Request is directed to another server: The server name is * longer * than * the request name. Drop this case here to avoid overflows * in * the * following checks.

Data block

If a file should not be cached, do not only send * max-age=0, but also pragmas and Expires headers.

1 is CRYPTO_LOCK

keep legacy behavior

difftime for struct timespec. Return value is in seconds.

OK

Compiler information

If CGI file is a script, try to read the interpreter line

Is path itself a directory?

Read from the socket into the next available location in the * message queue.

process HTTP connection

12. Directory uris should end with a slash

return 0 on success, just like fclose

And disabling them does not work either: * #pragma clang diagnostic ignored "-Wno-error=date-time" * #pragma clang diagnostic ignored "-Wdate-time" * So we just have to disable ALL warnings for some lines * of code.

Server did not recv anything -> just close the connection

Start master (listening) thread

RFC2616 Section 10.2.1

EBUSY

out of memory

Debug: * printf("Missing function: %s\n", fp->name);

is still not MIT) and use dynamic binding like

body_len is the length of the entire queue in bytes * len is the length of the current message * data_len is the length of the current message's data payload * header_len is the length of the current message's header

Get some operating system independent thread id

Note: mg_snprintf will not cause a buffer overflow above. * So, string truncation checks are not required here.

open a connection

so->lsa.sin6.sin6_family = AF_INET6; already set by mg_inet_pton

Add 1 to len for the + character we skipped before

RFC2616 Section 10.4.18

If the path is not complete, skip processing.

Access granted

Port is specified with a +, bind to IPv6 and IPv4, INADDR_ANY

IANA registered MIME types * (http://www.iana.org/assignments/media-types) * application types

This is the problematic case for CRYPTO_set_id_callback: * The OS pthread_t can not be cast to unsigned long.

Server starts *now*

SSL context

defined(_WIN32) && !defined(__SYMBIAN32__) - \ WINDOWS / UNIX include block

PATCH method (RFC 5789)

Free Lua state of lua background task

chunksize not set correctly

Pointer to name (in user addr space).

Overflow case

Try to read until it succeeds, fails, times out, or the server * shuts down.

padding added after data member

data is "var1=val1&var2=val2...". Find variable first

Wait until everything has stopped.

RFC2616 Section 10.5.4

Send a chunk, if "Transfer-Encoding: chunked" is used

copy from the remainder of the last received chunk

Total bytes sent to client

Receive error

Transfer-Encoding is chunked: * 0 = not chunked, * 1 = chunked, do data read yet, * 2 = chunked, some data read, * 3 = chunked, all data read

Public function to check http digest authentication header

processed

Parameter error

next try for a partial match, we will accept uri/something

defined(__GNUC__) || defined(__MINGW32__)

11. Handle put/delete/mkcol requests

RFC2616 Section 10.2 - Successful 2xx

model

6.2.2. Check if put authorization for static files is * available.

may be NULL

sscanf() is safe here, since send_ssi_file() also uses buffer * of size MG_BUF_LEN to get the tag. So strlen(tag) is * always < MG_BUF_LEN.

Publish the content length back to the response info.

Parent

File properties filled by mg_fopen:

CGI error handler should show the status code

Fatal error - abort start. However, this situation should never * occur in practice.

Size of the accepted socket queue

IPv6

RFC 6585, Section 5

finally try for pattern match

If file name is fishy, reset the file structure and return * error. * Note it is important to reset, not just return the error, cause * functions like is_file_opened() check the struct.

Put the temp file in place of real file

Compile-time option to control stack size, * e.g. -DUSE_STACK_SIZE=16384

Return True if we should reply 304 Not Modified.

Do not compress ranges.

11.1. PUT method

!_WIN32 && !__SYMBIAN32__

IPv6 address, examples: see above

Add user-specified variables

Delete is not successful: Return 500 (Server error).

On Windows, the file creation time can be higher than the * modification time, e.g. when a file is copied. * Since the Last-Modified timestamp is used for caching * it should be based on the most recent timestamp.

Buffer allocation successful. Store the string there.

or timeout occured * => the code must stay in the while loop

lock while cert is reloading

thread was not created

strcat with additional NULL check to avoid clang scan-build warning.

Return buffered data

MINGW typedefs pid_t to int. Using #define here.

If PEM file is not specified and the init_ssl callback * is not specified, skip SSL initialization.

closed

Each error code path in this function must send an error

Forward declaration for Windows

Feature check API function

Start a thread storing the thread context.

RFC2616 Section 10.3 - Redirection 3xx

Reallocate the buffer

Always put directories on top

REPORT method (RFC 3253)

Will only work for RFC 952 compliant hostnames, * starting with a letter, containing only letters, * digits and hyphen ('-'). Newer specs may allow * more, but this is not guaranteed here, since it * may interfere with rules for port option lists.

ext now points to the path suffix

defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1)

assert(conn->data_len <= conn->buf_size);

Deprecated: Use mg_get_server_ports instead.

Content length is not specified by the client.

RFC2616 Section 10.3.1

Two \r\n - standard compliant

assert(is_delete_request || connect_handler!=NULL || * ready_handler!=NULL || data_handler!=NULL || * close_handler!=NULL);

End of civetweb.c

We sent an "upgrade" request. For a correct websocket * protocol handshake, we expect a "101 Continue" response. * Otherwise it is a protocol violation. Maybe the HTTP * Server does not know websockets.

14. directories

Don't wait if the server is going to be stopped.

Values from errno.h in Windows SDK (Visual Studio).

Decode variable into destination buffer

!EWOULDBLOCK

The second word is the URI

1.2. do a https redirect, if required. Do not decode URIs yet.

File exists (precondition for calling this function), * but can not be opened by the server.

out: file found (directly)

mg_stat returns 0 if the file does not exist

POST or PUT request without content length set

Get Subject and issuer

set_ssl_option() function updates this array. * It loads SSL library dynamically and changes NULLs to the actual addresses * of respective functions. The macros above (like SSL_connect()) are really * just calling these functions indirectly via the pointer.

No Tag

out: websocket connetion?

Calculate how much to read from the file in the buffer

ok = FALSE; already set by init

RFC2324 Section 2.3.2

file stored on disk

If we don't memset stat structure to zero, mtime will have * garbage and strftime() will segfault later on in * print_dir_entry(). memset is required only if mg_stat() * fails. For more details, see * http://code.google.com/p/mongoose/issues/detail?id=79

Thread local storage index

See https://www.chilkatsoft.com/p/p_299.asp

For given directory path, substitute it to valid index file. * Return 1 if index file has been found, 0 if not found. * If the file is found, it's stats is returned in stp.

isgraph or isspace = isprint

Read from IO channel - opened file descriptor, socket, or SSL descriptor. * Return value: * >=0 .. number of bytes successfully read * -1 .. timeout * -2 .. error

Add data bytes in the current chunk have been read, * so we are expecting \r\n now.

9a. In case the server uses only callbacks, this uri is * unknown. * Then, all request handling ends here.

last_modified = now ... assumes the file may change during * runtime, * so every mg_fopen call may return different data

HTTP reply status code, e.g. 200

Master thread adds accepted socket to a queue

shutdown of the socket at client side

BEGIN: CLOCK_MONOTONIC = stopwatch (time differences)

:# is a comment

This server does not have any real files, thus the * PUT/DELETE methods are not valid.

The headers "Host", "Sec-WebSocket-Key", "Sec-WebSocket-Protocol" and * "Sec-WebSocket-Version" are also required. * Don't check them here, since even an unsupported websocket protocol * request still IS a websocket request (in contrast to a standard HTTP * request). It will fail later in handle_websocket_request.

While the delimiter is quoted, look for the next delimiter.

Create a temporary file name. Length has been checked before.

Size of structures, aligned to 8 bytes

Ignore errors for readonly files

Process a connection - may handle multiple requests * using the same connection. * Must be called with a valid connection (conn and * conn->ctx must be valid).

in: filename (must be valid)

PATCH method only allowed for CGI/Lua/LSP and callbacks.

Skip over '=' character

Avoid CRYPTO_cleanup_all_ex_data(); See discussion: * https://wiki.openssl.org/index.php/Talk:Library_Initialization

The first word is the HTTP version

Dynamically load SSL library. Set up ctx->ssl_ctx pointer.

Mark required libraries

Keep reading the input (either opened file descriptor fd, or socket sock, * or SSL descriptor ssl) into buffer buf, until \r\n\r\n appears in the * buffer (which marks the end of HTTP request). Buffer buf may already * have some data. The length of the data is stored in nread. * Upon every read operation, increase nread by the number of bytes read.

Send len bytes from the opened file to the client.

Message is a valid request

!fileno MINGW #defines fileno

PROPPATCH, COPY, MOVE, LOCK, UNLOCK (RFC 2518)

Set linger option to avoid socket hanging out after close. This * prevent ephemeral port exhaust problem under high QPS.

GCC seems to have a flaw with it's own socket macros: * http://www.linuxquestions.org/questions/programming-9/impossible-to-use-gcc-with-wconversion-and-standard-socket-macros-841935/

C++ wants that for INT64_MAX

Some of the parameters may be NULL

Lua Script

not required anyway

This is a POST/PUT request, or another request with body data.

Copy the data payload into the data pointer for the * callback. Cast to 31 bit is OK, since we * limited data_len

!USE_WEBSOCKET

Default: don't configure any linger

Content-Length header value

NO_CACHING

Send headers

Deallocate context itself

Sleep quantum in ms

CORS request is asking for additional headers

Last time throttled data was sent

p must correspond to end_word - 1

the ready handler returned false

Send 304 "Not Modified" - this must not send any body data

last_modified = conn->ctx.start_time; * May be used it the data does not change during runtime. This * allows * browser caching. Since we do not know, we have to assume the file * in memory may change.

File exists and is not a directory.

Terminate string

Print error message to the opened error log stream.

worst case

According to RFC 2616, Section 14.21, caching times should not exceed * one year. A year with 365 days corresponds to 31536000 seconds, a * leap * year to 31622400 seconds. For the moment, we just send whatever has * been configured, still the behavior for >1 year should be considered * as undefined.

The pre-allocated buffer not large enough.

Can it be replaced?

HTTP (RFC 2616)

Tag is opening

draft-tbray-http-legally-restricted-status-05, * Section 3

path does not exixt and can not be created

Propagate the error

USE_SERVER_STATS

Step 2: If a callback is responsible, call it.

This is an existing file (not a directory). * Check if write permission is granted.

http://msdn.microsoft.com/en-us/library/ms739165(v=vs.85).aspx: * "Note that enabling a nonzero timeout on a nonblocking socket * is not recommended.", so set it to blocking now

Use a local copy here, since substitute_index_file will * change the content of the file status

6. authorization check

94

Close, if keep alive is not enabled

Unknown success code

RFC2616 Section 10.5.5

Use 64-bit file offsets by default

Return OpenSSL error message (from CRYPTO lib)

done with OpenSSL

sendfile is only available for Linux

For the moment, use option c: We look for a proper file, * but since a file request is not always a script resource, * the authorization check might be different.

Request buffers are not pre-allocated. They are private to the * request and do not contain any state information that might be * of interest to anyone observing a server status.

This function is called from send_directory() and used for * sorting directory entries by size, or name, or modification time. * On windows, __cdecl specification is needed in case if project is built * with __stdcall convention. qsort always requires __cdels callback.

Frame format: http://tools.ietf.org/html/rfc6455#section-5.2

Partial content

The websocket_client context has only this thread. If it runs out, set the stop_flag to 2 (= "stopped").

2. if this ip has limited speed, set it for this connection

sscanf and the option splitting code ensure the following condition

RFC2616 Section 10.4.1

Open file for read only access

look for matching subprotocol

34

Publish the content length back to the request info.

read error

416 = Range Not Satisfiable

Ignore too long entries that may overflow path buffer

remove double backslash (check i > 0 to preserve UNC paths, * like \\server\file.txt)

DNS is case insensitive, so use case insensitive string compare here

The RFC standard version (https://tools.ietf.org/html/rfc6455) * requires a Sec-WebSocket-Key header.

GetVersion was declared deprecated

End of header key (*dp == ':')

Parsed Authorization header

Linux et al already use unicode. No need to convert.

Comma found. Store length and shift the list ptr

hpux

step 1. completed, the url is known now

RFC2518 Section 10.2, RFC4918 Section 11.1

Set bits for available features according to API documentation. * This bit mask is created at compile time, according to the active * preprocessor defines. It is a single const value at runtime.

RFC says that all initial whitespaces should be ingored

Add this thread to cv's waiting list

must be a end of line

Memory information

pollres = 0 means timeout

Copy VARIABLE=VALUE\0 string into the free space

video

CGI scripts may support all HTTP methods

All calls to construct_etag use 64 byte buffer

POSIX dirent interface

Prepare the environment block

Size of the request + headers in a buffer

Initialize elements.

Used by mg_(un)lock_connection to ensure * atomic transmissions for websockets

see errno

File name is relative to the webserver root

Timeout occured, but no data available.

If there is anything beyond end_word, copy it.

Websocket Lua script

NO_SOCKLEN_T

Note: set_sock_timeout is not required for non-blocking sockets. * Leave this function here (commented out) for reference until * CivetWeb 1.9 is tested, and the tests confirme this function is * no longer required.

timeout

Valid URIs according to RFC 3986 * (https://www.ietf.org/rfc/rfc3986.txt) * must only contain reserved characters :/?#[]@!$&'()*+,;= * and unreserved characters A-Z a-z 0-9 and -._~ * and % encoded symbols.

RFC2616 Section 10.2.5

IE uses commas, FF uses * spaces

if an error occured, close the connection

Stringify binary data. Output buffer must be twice as big as input, * because each byte takes 2 bytes in string representation

Point p to variable value

This is the hixie version

error

set an error, if not yet set

HTTP 1.1 default is keep alive

Convert in 32 bit words, if data is 4 byte aligned

RFC2518 Section 10.1

1 if gzip encoding is accepted

Check if the script file is in a path, allowed for script files. * This can be used if uploading files is possible not only for the server * admin, and the upload mechanism does not check the file extension.

update existing handler

nanoseconds

Return HTTP header value, or NULL if not found.

Then send length information, chunk and terminating \r\n.

Allocate new buffer

Initialize thread local storage

1.3. decode url (if config says so)

Child

Skip over leading LWS

timeout: return 0

Now read CGI reply into a buffer. We need to set correct * status code, thus we need to see all HTTP headers first. * Do not send anything back to client, until we buffer in all * HTTP headers.

Parsing failure.

RFC2616 Section 10.4.15

See table: http://www.cplusplus.com/reference/cctype/

See IANA HTTP status code assignment: * http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

Ok

seconds

Start a thread to read the websocket client connection * This thread will automatically stop when mg_disconnect is * called on the client connection

Describes listening socket, or socket which was accept()-ed by the master * thread and queued for future handling by the worker thread.

BEGIN: unknown clock

Should get data, but got EOL

socket error - check errno

!defined(NO_SSL)

RFC2616 Section 10.4.2

Protocol violation

Allocate a new buffer.

Interface function. Parameters are provided by the user, so do * at least some basic checks.

_WIN32_WCE

Flush current buffer

Check config, if index scripts may have sub-resources

defined(USE_WEBSOCKET)

Step 2.1 check and select subprotocol

Step 8: Check if the file exists at the server

Is port supposed to redirect everything to SSL * port

Step 9: Check for zipped files:

Need to retry the function call "later". * See https://linux.die.net/man/3/ssl_get_error * This is typical for non-blocking sockets.

Return 0 means, path itself is a directory.

RFC2616 Section 10.4.5

1. get the request url

Not chunked: content length is known

This is an SSL specific error

Send a response to CORS preflights only if * access_control_allow_methods is not NULL and not an empty string. * In this case, scripts can still handle CORS.

RFC2518 Section 10.3, RFC4918 * Section 11.2

Environment buffer

call init_thread for a worker thread (type 1)

Message is a valid response

Step 4: Check if gzip encoded response is allowed

Flush if buffer is full

Copy socket to the queue and increment head

could use atomic compare exchange, but this * seems overkill for statistics data

Throttling, bytes/sec. <= 0 means no * throttle

Stop signal received: somebody called mg_stop. Quit.

Client

O_BINARY

HCP24: some changes to compare hole var_name

This version uses 8 byte body data in a GET request

ALTERNATIVE_QUEUE

could use SSL_CTX_set_default_passwd_cb_userdata

Since we know all sockets, we can shutdown the connections.

hope nobody uses this

Requests information

Mark memory as dead

Get system information. It can be printed or stored by the caller. * Return the size of available information.

Delete is successful: Return 204 without content.

File should be created

Allow only if access_control_allow_headers is * not NULL and not an empty string. If this * configuration is set to *, allow everything. * Otherwise this configuration must be a list * of allowed HTTP header names.

accepted subprotocols for ws/wss requests.

Shut down signal

SSL is not supported

First satisfy needs of the server

http://msdn.microsoft.com/en-us/library/1w06ktdy.aspx

EINTR can be generated on a socket with a timeout set even * when SA_RESTART is effective for all relevant signals * (see signal(7)). * => stay in the while loop

Darwin prior to 7.0 and Win32 do not have socklen_t

Using the given file format, user name and domain must not contain * ':'

Flush buffer

Perform case-insensitive match of string against pattern

Make modifiable copy of the auth header

Only accept a full file path, not a Windows short (8.3) path.

timeout is handled by the while loop

mask flag and opcode

Implement the deprecated mg_upload function by calling the new * mg_handle_form_request function. While mg_upload could only handle * HTML forms sent as POST request in multipart/form-data format * containing only file input elements, mg_handle_form_request can * handle all form input elements and all standard request methods.

NOTE(lsm): order is important here. should_keep_alive() call * is using parsed request, which will be invalid after * memmove's below. * Therefore, memorize should_keep_alive() result now for later * use in loop exit condition.

Run SSL_shutdown twice to ensure completly close SSL connection

Step 1.3: Could check for "Host", but we do not really nead this * value for anything, so just ignore it.

processing

A websocket protocoll has the following HTTP headers: * * Connection: Upgrade * Upgrade: Websocket

Make sure the port is valid and vector ends with 's', 'r' or ','

Null-terminate the destination

assert(connect_handler==NULL && ready_handler==NULL && * data_handler==NULL && close_handler==NULL);

Deallocate request handlers

Request too long

Unknown server error code

Set to 1 if the content is gzipped, in which * case we need a "Content-Eencoding: gzip" header

character is ok

destructor not supported for Windows

Length of the message being read at the front of the * queue. Cast to 31 bit is OK, since we limited * data_len before.

remove existing handler

Get a unique thread ID as unsigned long, independent from the data type * of thread IDs defined by the operating system API. * If two calls to mg_current_thread_id return the same value, they calls * are done from the same thread. If they return different values, they are * done from different threads. (Provided this function is used in the same * process context and threads are not repeatedly created and deleted, but * CivetWeb does not do that). * This function must match the signature required for SSL id callbacks: * CRYPTO_set_id_callback

Convert the nonce from the client to a number.

Linear congruential generator

ASN1_digest is deprecated. Do the calculation manually, * using EVP_Digest.

Open failed

if clock_gettime is declared, then __CLOCK_AVAILABILITY will be defined

Regard empty password as no password - remove user record.

data points to the place where the message is stored when passed to * the * websocket_data callback. This is either mem on the stack, or a * dynamically allocated buffer if it is too large.

This function only checks if the uri is valid, not if it is * addressing the current server. So civetweb can also be used * as a proxy server.

Check if the request is directed to a different server.

URI: /path_to_script/ ... using index.cgi

This file can not be sent using sendfile. * This might be the case for pseudo-files in the * /sys/ and /proc/ file system. * Use the regular user mode copy code instead.

Send chunk of data that may have been read after the headers

The body data is completed when the connection * is closed.

Allocate a mutex for this connection to allow communication both * within the request handler and from elsewhere in the application

Ignore SIGPIPE signal, so if browser cancels the request, it * won't kill the whole process.

Do not delete anything shorter

Check for quotechar

Step 5: The websocket connection has been accepted

BEGIN: CLOCK_PROCESS = CPU usage of process

Assume the data may change during runtime by setting * last_modified = now

END: unknown clock

The converted number corresponds to the time the nounce has been * created. This should not be earlier than the server start.

Parse HTTP request, fill in mg_request_info structure. * This function modifies the buffer by NUL-terminating * HTTP request components, header names and header values. * Parameters: * buf (in/out): pointer to the HTTP header to parse and split * len (in): length of HTTP header buffer * re (out): parsed header as mg_request_info * buf and ri must be valid pointers (not NULL), len>0. * Returns <0 on error.

!NO_SSL

Check for a valid HTTP version key

Step 10: Script resources may handle sub-resources

Find end of HTTP header

Return stringified MD5 hash for list of strings. Buffer must be 33 bytes.

standard case if called from close_socket_gracefully

Look at the "path" extension and figure what mime type it has. * Store mime type in the vector.

Step 1: Set all initially unknown outputs to zero

RFC7238 Section 3

Name/Pattern of the URI.

Request is directed to another server: It could be a * substring * like notmyserver.com

Next would be the HTTP version

Get SSL client certificate information (if set)

If any ACL is set, deny by default

For every system, "(sizeof(int) == sizeof(void *))" is either always * true or always false. One of the two branches is unreachable in any case. * Unfortunately the C standard does not define a way to check this at * compile time, since the #if preprocessor conditions can not use the sizeof * operator as an argument.

USE_LUA

For sockets, wait for the socket using select

Script was in an illegal path

Make up and send the status line

Check end of word

RFC 2774, Section 7

Check if the nonce is too high, so it has not (yet) been used by the * server.

Reset buffer, so we can always use strcat.

Connection structure has been pre-allocated

Convert to Unicode and back. If doubly-converted string does not * match the original, something is fishy, reject.

Wrap pointers if needed

SSL context for client connections

deallocate system name string

Fatal error - abort start. However, this situation should * never occur in practice.

Store the ssl library handle.

RFC2616 Section 10.4.13

Get context information. It can be printed or stored by the caller. * Return the size of available information.

mg_stat must fill all fields, also for files in memory

Put so socket structure into the queue

pthread cond not available

SCRIPT_NAME

Start the server

none found

RFC2616 Section 10.1.1

NOTE(lsm): due to a bug in MSIE, we do not compare the URI

sf_sent<0 means error, thus fall back to the classic way

Now we know that our FIN is ACK-ed, safe to close

End of initial operating system specific define block.

If truncated, add "..."

Helper function for deprecated mg_upload.

Request to create a directory has been fulfilled successfully. * No need to put a file.

add mask

Step 5: If there is no root directory, don't look for files.

put_dir returns -1 if the path is too long

Both read and were successful, adjust counters

Try to delete it.

Compile-time option to control stack size, e.g. * -DUSE_STACK_SIZE=16384

Windows SO_REUSEADDR lets many procs binds to a * socket, SO_EXCLUSIVEADDRUSE makes the bind fail * if someone already has the socket -- DTL

ORDERPATCH (RFC 3648)

1 if connection must be closed

!NO_POPEN

linked list of uri handlers

Mark handles that should not be inherited. See * https://msdn.microsoft.com/en-us/library/windows/desktop/ms682499%28v=vs.85%29.aspx

Request/response has content length set

Could be a hostname

asterisk

GCC does not realize one branch is unreachable, so it raises some * pointer cast warning within the unreachable branch.

The first word has to be the HTTP method

Send host, port, uri and (if it exists) ?query_string

8.3: If the request target is a directory, there could be * a substitute file (index.html, index.cgi, ...).

Tag to long for buffer

This is an IO error. Look at errno.

RFC2616 Section 10.4.6

Context has been created - init user libraries

error callint poll

According to https://en.wikipedia.org/wiki/Symbian#History, * Symbian is no longer maintained since 2014-01-01. * Recent versions of CivetWeb are no longer tested for Symbian. * It makes no sense, to support an abandoned operating system. * All remaining "#ifdef __SYMBIAN__" cases will be droped from * the code sooner or later.

Note that root == NULL is a regular use case here. This occurs, * if all requests are handled by callbacks, so the WEBSOCKET_ROOT * config is not required.

Currently gz files can not be scripts.

A file should be created or overwritten.

Some ANSI #includes are not available on Windows CE

assert(fp != NULL);

Update lsa port in case of random free ports

If Range: header specified, act accordingly

Deallocate config parameters

EAGAIN/EWOULDBLOCK: * standard case if called from close_socket_gracefully * => should return -1

IPv4

Strings returned from bn_bn2hex must be freed using OPENSSL_free, * see https://linux.die.net/man/3/bn_bn2hex

call the init_connection callback if assigned

Create substitutes for POSIX functions in Win32.

Unified socket address. For IPv6 support, add IPv6 address structure in * the * union u.

Step 4: Check if there is a responsible websocket handler.

For every compiler, either "sizeof(pthread_t) > sizeof(unsigned long)" * or not, so one of the two conditions will be unreachable by construction. * Unfortunately the C standard does not define a way to check this at * compile time, since the #if preprocessor conditions can not use the sizeof * operator as an argument.

Check if the method is known to the server. The list of all known * HTTP methods can be found here at * http://www.iana.org/assignments/http-methods/http-methods.xhtml

RFC2616 Section 10.4 - Client Error 4xx

Step 6: Call the ready handler

See CONTEXT_* above

Store the <

Set default value if needed

There should be already an error message

Timeout in s:

Adjust length for trailing LWS

1.1.1970 in filedate

put_dir returns 0 if path is a directory

Point s to the end of the value

Could not parse the CGI response. Check if some error message on * stderr.

Log is written to a file and/or a callback. If both are not set, * executing the rest of the function is pointless.

Buffer size

Yes it does, break the loop

Send all current and obsolete cache opt-out directives.

Return 1 on success. Always initializes the ah structure.

Calculate SHA1 fingerprint and store as a hex string

Yes, they are optional

RFC 6585, Section 6

_WIN32

Parse HTTP headers from the given buffer, advance buf pointer * to the point where parsing stopped. * All parameters must be valid pointers (not NULL). * Return <0 on error.

The master thread ID

Threads have different return types on Windows and Unix.

Free client certificate info

Return 1 if request is authorised, 0 otherwise.

ignore leading whitespaces

Open file for writing, create and append

Check if the server may write this file

Scan user-defined mime types first, in case user wants to * override default mime types.

Get serial number

Here stop_flag is 1 - Initiate shutdown.

Return NULL or the relative uri at the current server

value of request_timeout is in seconds, config in milliseconds

Lua_State for a websocket connection

Encode 'path' which is assumed UTF-8 string, into UNICODE string. * wbuf and wbuf_len is a target buffer and its length.

The worker thread IDs

Take connection [idx]. This connection is not locked in * any way, so some other thread might use it.

"The masking key is a 32-bit value chosen at random by the client." * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17#section-5

Out of memory

Set socket family to IPv6, do not use IPV6_V6ONLY

Server version

Other request

Signaled when socket is produced

Call consume_socket() even when ctx->stop_flag > 0, to let it * signal sq_empty condvar to wake up the master waiting in * produce_socket()

ready

Set close flag, so keep-alive loops will stop

RFC2616 Section 10.1 - Informational 1xx

6.3. This is either a OPTIONS, GET, HEAD or POST request, * or it is a PUT or DELETE request to a resource that does not * correspond to a file. Check authorization.

Timeout

Set to 1 if mg_stat is called for a directory

No option known to set thread name for MinGW

Do not open file (used in is_file_in_memory)

CGI is not supported

assert(option != NULL); assert(option[0] != '\0');

11.4. PATCH method * This method is not supported for static resources, * only for scripts (Lua, CGI) and callbacks.

to expose flockfile and friends in stdio.h

Check the user's password, return 1 if OK

This is always the case, if sf_file is not a "normal" file, * e.g., for sending data from the output of a CGI process.

See also https://www.mnot.net/cache_docs/

mg_init_library counter

End of the list

If it is a directory, print directory entries too if Depth is not 0

This is not a valid field.

The handler did NOT handle the request.

for setgroups()

User supplied argument for the handler function.

Set IPv6 only option, but don't abort on errors.

The second word is the status as a number

This is a valid CORS preflight, and the server is configured * to * handle it automatically.

char **envp

IPv6 hex string is 46 chars

Send user defined error pages, if defined

Cross-origin resource sharing (CORS).

Prepare connection data structure

fail early, don't waste time checking other header * fields

if it's not the end of line, there must be a next word

Protects nonce_count

filep->is_directory = 0; filep->gzipped = 0; .. already done by * memset

Use memcpy for alignment

control characters and spaces are invalid

RFC 2295, Section 8.1

Do not add truncated strings to the environment

This happens, e.g., in calls from parse_auth_header, * if the user name contains a " character.

HTTPS connection

Define the initial recursion depth for procesesing htpasswd files that * include other htpasswd * (or even the same) files. It is not difficult to provide a file or files * s.t. they force civetweb * to infinitely recurse and then crash.

ebuf is set by connect_socket, * free all memory and return NULL;

Value is either quote-delimited, or ends at first comma or space.

Reset all outputs

Initialize thread local storage before calling any callback

WINDOWS / UNIX include block

Directory entry

No more data to read

file stored in memory

Do not show current dir and hidden files

Size was set by the callback

Prepare Etag, Date, Last-Modified headers. Must be in UTC, * according to * http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3

Visual Studio 6 does not know __func__ or __FUNCTION__ * The rest of MS compilers use __FUNCTION__, not C99 __func__ * Also use _strtoui64 on modern M$ compilers

RFC2616 Section 10.3.5

The 'path' given to us points to the directory. Remove all trailing * directory separator characters from the end of the path, and * then append single directory separator character.

Close files

Combining two pseudo-random number generators and a high resolution * part * of the current server time will make it hard (impossible?) to guess * the * next number.

RFC2616 Section 10.4.7

If Content-Length is not set for a request with body data * (e.g., a PUT or POST request), we do not know in advance * how much data should be read.

Return -1 in an error case

Set reuse option, but don't abort on errors.

16-bit length field

Does it exist?

Check if the config_options and the corresponding enum have compatible * sizes.

Finally check if the server corresponds to the authentication * domain of the server (the server domain). * Allow full matches (like http://mydomain.com/path/file.ext), and * allow subdomain matches (like http://www.mydomain.com/path/file.ext), * but do not allow substrings (like * http://notmydomain.com/path/file.ext * or http://mydomain.com.fake/path/file.ext).

pthread_t may be any data type, so a simple cast to unsigned long * can rise a warning/error, depending on the platform. * Here memcpy is used as an anything-to-anything cast.

Ignore truncation in access log

This code uses static_assert to check some conditions. * Unfortunately some compilers still do not support it, so we have a * replacement function here.

stdin read

Truncate here and set the key name

All SSI tags start with <!--#

END: CLOCK_REALTIME

Note that C callbacks are no longer called when Lua is * responsible, so C can no longer filter callbacks for Lua.

Legacy before split into local_uri and request_uri

Convert month to the month number. Return -1 on error, or month number

Append VARIABLE=VALUE\0 string to the buffer, and add a respective * pointer into the vars array. Assumes env != NULL and fmt != NULL.

Reallocate existing block

key == pthread_getspecific(sTlsKey);

restore the string

Number of requests handled by this connection

Behaves like realloc(), but frees original pointer on failure

Reference counter for crypto library.

8.2: Check if it is a script type.

Do nothing, callback has served the request. Store * then return value as status code for the log and discard * all data from the client not used by the callback.

The connection struct, pre- * allocated for each worker

Chunked encoding: 3=chunk read completely * completely

_WIN32 && !__SYMBIAN32__

For Windows, change all slashes to backslashes in path names.

Depending on the OpenSSL version, the callback may be * 'void (*)(SSL *, int, int)' or 'void (*)(const SSL *, int, int)' * yielding in an "incompatible-pointer-type" warning for the other * version. It seems to be "unclear" what is correct: * https://bugs.launchpad.net/ubuntu/+source/openssl/+bug/1147526 * https://www.openssl.org/docs/man1.0.2/ssl/ssl.html * https://www.openssl.org/docs/man1.1.0/ssl/ssl.html * https://github.com/openssl/openssl/blob/1d97c8435171a7af575f73c526d79e1ef0ee5960/ssl/ssl.h#L1173 * Disable this warning here. * Alternative would be a version dependent ssl_info_callback and * a const-cast to call 'char *SSL_get_app_data(SSL *ssl)' there.

defined(__GNUC__)

Protects (max|num)_threads

Discard all buffered data for this request

Set the time the request was received. This value should be used for * timeouts.

connected with IPv6

assert(conn->request_len < 0 || conn->data_len >= conn->request_len);

Server start time, used for authentication * and for diagnstics.

Tag is closing

stdout write

!NO_CACHING

Set linger timeout

Reserved for future use, must be zero.

BEGIN: CLOCK_THREAD = CPU usage of thread

Deprecated function mg_upload - use mg_handle_form_request instead.

assert(ebuf[0] != '\0');

Parse all HTTP headers

Ignore if a file in memory is inside a folder

We got ready to write. Don't check the timeout * but directly go back to write again.

Error, no bytes read

NO_SSL_DL

Random number generator will initialize at the first call

For a given PUT path, create all intermediate subdirectories. * Return 0 if the path itself is a directory. * Return 1 if the path leads to a file. * Return -1 for if the path is too long. * Return -2 if path can not be created.

http://www.webdav.org/specs/rfc4918.html, 9.1: * Some PROPFIND results MAY be cached, with care, * as there is no cache validation mechanism for * most properties. This method is both safe and * idempotent (see Section 9.1 of [RFC2616]).

Apply mask if necessary

A helper function for checking if a comma separated list of values * contains * the given option (case insensitvely). * 'header' can be NULL, in which case false is returned.

A helper function for traversing a comma separated list of values. * It returns a list pointer shifted to the next value, or NULL if the end * of the list found. * Value is stored in val vector. If value has form "x=y", then eq_val * vector is initialized to point to the "y" part, and val vector length * is adjusted to point only to "x".

Unknown redirection code

join worker thread

Remote socket address

Read frame payload from the first message in the queue into * data and advance the queue by moving the memory in place.

Not initialized yet

C runtime is not standard compliant, vsnprintf() returned -1. * Switch to alternative code path that uses incremental * allocations.

ignore error on read only file

Parse a buffer: * Forward the string pointer till the end of a word, then * terminate it and forward till the begin of the next word.

Windows return values: see * https://msdn.microsoft.com/en-us/library/windows/desktop/ms738520%28v=vs.85%29.aspx

This is the end of the header

5.2. check if the request will be handled by a callback

Handle to algorithm used for fingerprint

text

Calculate Sec-WebSocket-Accept reply from Sec-WebSocket-Key.

Step 1.1: Check Sec-WebSocket-Key.

This is just a quick fix if the client offers multiple * protocols. The handler should have a list of accepted * protocols on his own * and use it to select one protocol among those the client * has * offered.

It could be an absolute uri:

Just a single protocol -> accept it.

Delete was successful: Return 204 without content.

Must be 0x1000.

Calculate number of bytes added to the environment

Parse UTC date-time string, and return the corresponding time_t value.

is_file_in_memory returned true

Step 3.2: Lua is responsible: call it.

Time (since system start) when the request * was received

CGI must be executed in its own directory. 'dir' must point to the * directory containing executable program, 'p' must point to the * executable program name relative to 'dir'.

http://en.wikipedia.org/wiki/Advanced_Audio_Coding

Allocation failed, exit the loop and then close the * connection

Features

Socket already closed by client/peer, close socket without linger

Buffer is big enough

Alternative queue is well tested and should be the new default

ok

Use a const cast here and modify the string. * We are going to restore the string later.

callback already processed the request. Store the return value as a status code for the access log.

RFC2616 Section 10.5.3

The RFC version (https://tools.ietf.org/html/rfc6455) is 13.

audio

pthread_setname_np first appeared in glibc in version 2.12

DEBUG

Note that since V1.7 the "begin_request" function is called * before an authorization check. If an authorization check is * required, use a request_handler instead.

RFC2616 Section 10.3.4

However, the reasonable default is to not accept a nonce from a * previous start, so if anyone changed the access rights between * two restarts, a new login is required.

Include the header file here, so the CivetWeb interface is defined for the * entire implementation, including the following forward definitions.

Allocate context and initialize reasonable general case defaults.

Linux uses -1 on error, Windows NULL.

could use atomic compare exchange, but this * seems overkill for statistics data

not recognized on older compiler versions

Signaled when socket is consumed

out: file status structure

Send header

This is a file in memory, but we cannot store the * properties * now. * Called from "is_file_in_memory" function.

Connected client

Wakeup workers that are waiting for connections to handle.

1 if in handler for user defined error * pages

done

RFC 6585, Section 3

No more data to write

How many bytes of content have been read

Windows file systems are not case sensitive, but you can still use * uppercase and lowercase letters (on all modern file systems). * The server can check if the URI uses the same upper/lowercase * letters an the file system, effectively making Windows servers * case sensitive (like Linux servers are). It is still not possible * to use two files with the same name in different cases on Windows * (like /a and /A) - this would be possible in Linux. * As a default, Windows is not case sensitive, but the case sensitive * file name check can be activated by an additional configuration.

Return 0 on success, non-zero if an error occurs.

Connection object will be null if something goes wrong

Handler for http/https or authorization requests.

stdin write

We are in a tag, either SSI tag or html tag

The previous code must not add any header starting with X- to make * sure no one of the additional_headers is included twice

String truncation in buf may only occur if * error_handler is too long. This string is * from the config, not from a client.

RFC2616 Section 10.4.12

file is in memory

RFC2616 Section 10.2.4

assert(connect_handler==NULL && ready_handler==NULL && * data_handler==NULL && close_handler==NULL);

Thread ID (-1=caller thread).

RFC2616 Section 10.3.6

Check if the uri is valid. * return 0 for invalid uri, * return 1 for *, * return 2 for relative uri, * return 3 for absolute uri without port, * return 4 for absolute uri with port

Step 2: Check if the request attempts to modify the file system

0 = undef, numerical value may change in different * versions. For the current definition, see * mg_get_connection_info_impl

protocol found, port set

Is keep alive allowed by the server

assert(conn->data_len >= 0);

For client connections, mg_context is fake. Since we need to set a * callback function, we need to create a copy and modify it.

If we can't find the actual file, look for the file * with the same name but a .gz extension. If we find it, * use that and set the gzipped flag in the file struct * to indicate that the response need to have the content- * encoding: gzip header. * We can only do this if the browser declares support.

Open the given file and temporary file

If new user, just add it

large enough, so there will be no overflow

ws/wss client context

No body allowed. Close the connection.

Print properties for the requested resource itself

If a callback has been specified, call it.

in/out: request (must be valid)

If the queue is empty, wait. We're idle at this point.

free context

Step 3: Check if it is a websocket request, and modify the document * root if required

User-defined callback function

We have returned all buffered data. Read new data from the remote * socket.

Two newline, no carriage return - not standard compliant, * but * it * should be accepted

DEBUG_TRACE

125

This error code is unknown. This should not happen.

1.1. split into url and query string

call the connection_close callback if assigned

Step 8: Call the close handler

no handler to set, this was a remove request to a non-existing * handler

Everything else but a 3 digit code is invalid

TRACE method (RFC 2616) is not supported for security reasons

Linux, ... (not Windows)

NOTE: Maybe some data has already been sent.

NO_SSL

Value has form "x=y", adjust pointers and lengths * so that val points to "x", and eq_val points to "y".

Check explicit wish of the client

port remains 0 if the protocol is not found

USE_DUKTAPE

Perform redirect and auth checks before calling begin_request() * handler. * Otherwise, begin_request() would need to perform auth checks and * redirects.

GetProcAddress() returns pointer to function

Unknown informational status code

https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods

Establish the client connection and request upgrade

8.1: File exists.

Reset attributes. DO NOT TOUCH is_ssl, remote_ip, remote_addr, * remote_port

Do not read more than the total content length of the * request.

HAVE_POLL

Use of fopen here is OK, since fname is only ASCII

However, Linux does not return 0 on success either.

abort scan as soon as one malformed character is found

Config option name, config types, default value

normal end

URI: /path_to_script/script.cgi

Init variables

Reset user data, after close callback is called. * Do not reuse it. If the user needs a destructor, * it must be done in the connection_close callback.

in: size of filename buffer

The request addresses a CGI resource, Lua script or * server-side javascript. * The URI corresponds to the script itself (like * /path/script.cgi), and there is no additional resource * path (like /path/script.cgi/something). * Requests that modify (replace or delete) a resource, like * PUT and DELETE requests, should replace/delete the script * file. * Requests that read or write from/to a resource, like GET and * POST requests, should call the script and return the * generated response.

Internal function. Assumes conn is valid

Send read bytes to the client, exit the loop on error

HTTP 1.1 assumes keep alive if "Connection:" header is not set * This function must tolerate situations when connection info is not * set up, for example if request parsing failed.

The rest of the line is the value

Use read() instead of fread(), because if we're reading from the * CGI pipe, fread() may block until IO buffer is filled up. We * cannot afford to block and must pass all read bytes immediately * to the client.

Move the queue forward len bytes

Control characters are not allowed, including zero

Skip all following slashes, backslashes and double-dots

nonce is from a previous start of the server and no longer valid * (replay attack?)

RFC3229 Section 10.4.1

END: CLOCK_MONOTONIC

POSIX return values: see * http://pubs.opengroup.org/onlinepubs/9699919799/functions/freeaddrinfo.html

server context

vsnprintf must not be used in any system, * \ \ \ \ * but this define only works well for Windows.

NOTE: override filep->size only on success. Otherwise, it * might * break constructs like if (!mg_stat() || !mg_fopen()) ...

RFC2616 Section 10.5.1

RFC 2817 Section 4

1.4. clean URIs, so a path like allowed_dir/../forbidden_file is * not possible

RFC2616 Section 10.4.8

RFC2518 Section 10.6, RFC4918 * Section 11.5

Using filename_buf_len - 1 because memmove() for PATH_INFO may shift * part of the path one byte on the right.

The mg_upload function is superseeded by mg_handle_form_request.

5.1. first test, if the request targets the regular http(s):// * protocol namespace or the websocket ws(s):// protocol namespace.

Step 6: Determine the local file path from the root path and the * request uri.

Handler for specific error, e.g. 404 error

Copy the stuff to temporary file

Print first entry - link to a parent directory

Not required for non-blocking sockets. set_sock_timeout(conn->client.sock, timeout);

Sanity check the offset

Mask for all nonce values

Allocation failed. Return -1 as "out of memory" error.

dummy for SSL argument to push/pull

inline 7-bit length field

No truncation check for ebuf

Copy socket from the queue and increment tail

pthread mutex not available

Adjust number of bytes to read.

OPENSSL_API_1_1

Unknown request error code

assert(auth_handler == NULL);

Other status codes, not shown in the IANA HTTP status code * assignment. * E.g., "de facto" standards due to common use, ...

Loop continuously, reading messages from the socket, invoking the * callback, and waiting repeatedly until an error occurs.

out: handled by a script?

Lua server page: an SSI like page containing mostly plain * html * code * plus some tags with server generated contents.

SSL callback documentation: * https://www.openssl.org/docs/man1.1.0/ssl/SSL_set_info_callback.html * https://linux.die.net/man/3/ssl_set_info_callback

fetch a new chunk

Error sending the body data

put_dir returns -2 if the directory can not be created

reset all members of fileacc

non-constant aggregate initializer: issued due to missing C99 support

pem is not NULL here

Execution time information

13. Handle other methods than GET/HEAD

lfsr will be only 0 if has not been initialized, * so this code is called only once.

unspecified - may change with the next version

First check if it is a list or just a single value.

could be deprecated global callback

SSL function name

Substitute file is a script file

Ignore any empty entries.

Skip the characters until one of the delimiters characters found. * 0-terminate resulting word. Skip the delimiter and following whitespaces. * Advance pointer to buffer to the next word. Return found 0-terminated * word. * Delimiters can be quoted with quotechar.

USE_TIMERS

Request is directed to a different port

Copy the mask before we shift the queue and destroy it

Errors 1xx, 204 and 304 MUST NOT send a body

next handler in a linked list

WinCE has no pipes

Prepare full path to the index file

We use (signed) cast below because MSVC 6 compiler cannot * convert unsigned __int64 to double. Sigh.

-1 for path too long, * -2 for path can not be created.

Invalid request

Use mg_cry here, since gpass has been configured.

Quick fix (for 1.9.x):

defined(_WIN32) && !defined(__SYMBIAN32__) - \ WINDOWS / UNIX include block

ssl already initialized

Unread data from the last chunk

13.2. Handle OPTIONS for files

Set linger option according to configuration

End of headers reached.

BEGIN: CLOCK_REALTIME = wall clock (date and time)

RFC2616 Section 10.5.2

RFC2616 Section 10.3.8

Thread index within ctx

Error while parsing headers

If there is no substitute file, the server could return * a directory listing in a later step

DTL -- including winsock2.h works better if lean and mean

USE_WEBSOCKET

Local file path and name, corresponding to requested URI * is now stored in "filename" variable.

failed

Convert time_t to a string. According to RFC2616, Sec 14.18, this must be * included in all responses other than 100, 101, 5xx.

Translate serial number to a hex string

SEARCH (RFC 5323)

File properties filled by mg_stat:

handler type

image

Important: using local struct mg_file to test path for * is_directory flag. If filep is used, mg_stat() makes it * appear as if auth file was opened. * TODO(mid): Check if this is still required after rewriting * mg_stat

first try for an exact match

see CONNECTION_TYPE_* above

Opcode == 8, connection close

For fseeko(), ftello()

Yes, they are mandatory

gai_strerror could be used to convert gai_ret to a string

defined(USE_STACK_SIZE) && USE_STACK_SIZE > 1

Support PATH_INFO for CGI scripts.

Copyright (c) 2013-2017 the Civetweb developers * Copyright (c) 2004-2013 Sergey Lyubka * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE.

Handler for all errors

Reject wrong versions

Include \n

A relative uri starts with a / character

Find end of status text

No error, but 0 bytes sent. May be EOF?

File does not exist. This is not always a problem here.

On the fly compression allowed

RFC2616 Section 10.5.6

If we compiled with Mac OSX 10.12 or later, then clock_gettime will be * declared but it may be NULL at runtime. So we need to check before using * it.

Open file for writing, create and overwrite

RFC2616 Section 10.4.4

Read the server config to check how long a file may be cached. * The configuration is in seconds.

file is on disk

Server is to be stopped.

Listening socket

This is an unknown version

Delete not successful (file locked).

find a free worker slot and signal it

WinCE does not support CGI pipes

File is already compressed. No "on the fly" compression.

Copy remaining data

Not an SSI tag

some data has been read, or no data was requested

This structure helps to create an environment for the spawned CGI * program. * Environment is an array of "VARIABLE=VALUE\0" ASCIIZ strings, * last element must be NULL. * However, on Windows there is a requirement that all these * VARIABLE=VALUE\0 * strings must reside in a contiguous buffer. The end of the buffer is * marked by two '\0' characters. * We satisfy both worlds: we create an envp array (which is vars), all * entries are actually pointers inside buf.

handle request to local server

This thread has been removed from cv's waiting list

Step 7: URI rewriting

one worker thread will be created

Space available in buf

dlsym() on UNIX returns void *. ISO C forbids casts of data * pointers to function pointers. We need to use a union to make a * cast.

Disable deprecation warning in VS2005

Use the global passwords file, if specified by auth_gpass option, * or search for .htpasswd in the requested directory.

RFC2616 Section 10.4.3

16 = Max. thread length in Linux/OSX/..

Check license (zlib has a permissive license, but

__SYMBIAN32__

6.2.1. thus, the server must have real files

Request is directed to another server: * The server name is different.

Call duktape to generate the page

The chain of threads

Bind to IPv4 only, since IPv6 is not built in.

Return at least a category according to RFC 2616 Section 10.

Accepted sockets

defined for tdm-gcc so we can use getnameinfo

The max request size

RFC2518 Section 10.4, RFC4918 Section 11.3

assert(conn->consumed_content == 0);

The request sent by the client could not be understood by * the server, or it was incomplete or a timeout. Send an * error message and close the connection.

Implementation of POSIX opendir/closedir/readdir for Windows.

Do not lock when getting the callback value, here and below. * I suppose this is fine, since function cannot disappear in the * same way string option can.

The pre-allocated buffer is large enough. * Use it to store the string and return the address.

Initialize output string

6.2. this request is a PUT/DELETE to a real file

WinCE has no popen

Poll returned either success (1) or error (-1). * Forward both to the caller.

output: socket, must not be NULL

The number of configured worker threads.

RFC2616 Section 10.4.10

Full request not yet received

6.1. a custom authorization handler is installed

Deallocate SSL context

Cannot determine if socket is already closed. This should * not occur and never did in a test. Log an error message * and continue.

Is valid

function has been selected for automatic inline expansion

Initialize locking callbacks, needed for thread safety. * http://www.openssl.org/support/faq.html#PROG1

file does not exist and will not be created

3 indicates a websocket client thread

GCC_VERSION >= 40500

This will fail file is the file is in memory

Make sure child closes all pipe descriptors. It must dup them to 0,1

Using fmt as a non-literal is intended here, since it is mostly called * indirectly by mg_snprintf

Note that POSIX/Winsock's send() is threadsafe * http://stackoverflow.com/questions/1981372/are-parallel-calls-to-send-recv-on-the-same-socket-valid * but mongoose's mg_printf/mg_write is not (because of the loop in * push(), although that is only a problem if the packet is large or * outgoing buffer is full).

C callback has returned non-zero, do not proceed with * handshake.

Apple OSX section

Reset ip_version to 0 of there is an error

on linux we can use the old prctl function

TCP_USER_TIMEOUT/RFC5482 (http://tools.ietf.org/html/rfc5482): * max. time waiting for the acknowledged of TCP data before the connection * will be forcefully closed and ETIMEDOUT is returned to the application. * If this option is not set, the default timeout of 20-30 minutes is used.

Default is "no".

Since we use a sleep quantum of some seconds to check for recv * timeouts, we will just wait a few seconds in mg_join_thread.

Free existing block

conditional expression is constant: introduced by FD_SET(..)

Verify given socket address against the ACL. * Return -1 if ACL is malformed, 0 if address is disallowed, 1 if allowed.

10. Request is handled by a script

Handle SSI tag

Not yet a valid request/response

This legacy interface only works for the IPv4 case

Cross-origin resource sharing (CORS), see * http://www.html5rocks.com/en/tutorials/cors/, * http://www.html5rocks.com/static/images/cors_server_flowchart.png * - * preflight is not supported for files.

RFC7540 Section 9.1.2

Incomplete request

We need to get the client thread out of the select/recv call * here.

Get connection information. It can be printed or stored by the caller. * Return the size of available information.

!_WIN32_WCE

File did not exist before fopen was called. * Maybe it has been created now. Get stat info * like creation time now.

if this file is in fact a pre-gzipped file, rewrite its filename * it's important to rewrite the filename after resolving * the mime type from it, to preserve the actual file's type

convert 1-3 remaining bytes if ((dataLen % 4) != 0)

Initialize SSL library

TODO: SSL_CTX_set_verify(conn->client_ssl_ctx, * SSL_VERIFY_PEER, verify_ssl_server);

Response code not even within reasonable range

Terminate and forward to the next word

absolute uri (with/without port)

There is no callback, and Lua is not responsible either.

11.2. DELETE method

_MSC_VER

For files, just wait a fixed time, * maybe an average disk seek time.

Unsupported WEBDAV Methods:

4. Check for CORS preflight requests and handle them (if configured). * https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS

Valid request

Forward until a space is found - use isgraph here

If callback returns 0, civetweb sets up the SSL certificate. * If it returns 1, civetweb assumes the calback already did this. * If it returns -1, initializing ssl fails.

forward_body_data failed. * The error code has already been sent to the client, * and conn->status_code is already set.

Return null terminated string of given maximum length. * Report errors if length is exceeded.

Data information

assert(discard_len >= 0);

Should we support client certificates?

Create the file if does not exist

Buffer for received data

Read and discard pending incoming data. If we do not do that and * close * the socket, the data in the send buffer may be discarded. This * behaviour is seen on Windows, when client keeps sending data * when server decides to close the connection; then when client * does recv() it gets no data back.

Terminate string and forward buf to next line

Send the rest of buffered data

Currently CivetWeb does not nead read+write access.

closing

assert(buffered_len >= 0);

0 means "do not cache". All values <0 are reserved * and may be used differently in the future.

If we're stopping, sq_head may be equal to sq_tail.

Reply with a 404 Not Found. We are still at a standard * HTTP request here, before the websocket handshake, so * we can still send standard HTTP error replies.

<inttypes.h> wants this for C++

Check whether full request is buffered. Return: * -1 if request or response is malformed * 0 if request or response is not yet fully buffered * >0 actual request length, including last \r\n\r\n

Use global passwords file

Close write end fdin and read end fdout and fderr

output: socket address, must not be NULL

this index file is a script

Try to create intermediate directory

All threads exited, no sync is needed. Destroy thread mutex and * condvars

Linear feedback shift register

Local socket address

Function pointer

init

According to the HTTP standard * http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.2 * URI can be an asterisk (*) or should start with slash (relative uri), * or it should start with the protocol (absolute uri).

Determine 32/64 bit data mode. * see https://en.wikipedia.org/wiki/64-bit_computing

-2 means "3rd party thread"

in ms

Search for \n from p till the end of stream

Valid listening port specification is: [ip_address:]port[s] * Examples for IPv4: 80, 443s, 127.0.0.1:3128, 192.0.2.3:8080s * Examples for IPv6: [::]:80, [::1]:80, * [2001:0db8:7654:3210:FEDC:BA98:7654:3210]:443s * see https://tools.ietf.org/html/rfc3513#section-2.2 * In order to bind to both, IPv4 and IPv6, you can either add * both ports using 8080,[::]:8080, or the short form +8080. * Both forms differ in detail: 8080,[::]:8080 create two sockets, * one only accepting IPv4 the other only IPv6. +8080 creates * one socket accepting IPv4 and IPv6. Depending on the IPv6 * environment, they might work differently, or might not work * at all - it must be tested what options work best in the * relevant network environment.

Bytes sent this second

http://sourceforge.net/p/predef/wiki/Compilers/

If the queue is full, wait

Used nonces, used for authentication

2147479552 (0x7FFFF000) is a limit found by experiment on * 64 bit Linux (2^31 minus one memory page of 4k?).

common use

Check for recursion

Fill in IP, port info early so even if SSL setup below fails, * error handler would have the corresponding info. * Thanks to Johannes Winkelmann for the patch.

Send FIN to the client

defined(_WIN32_WCE)

Read file, byte by byte, and look for SSI include tags

Only in case n=0 (timeout), repeat calling the write function

http://www.webdav.org/specs/rfc4918.html, 9.1: * When MKCOL is invoked without a request body, * the newly created collection SHOULD have no * members. A MKCOL request message may contain * a message body. The precise behavior of a MKCOL * request when the body is present is undefined, * ... ==> We do not support MKCOL with body data. * This method is idempotent, but not safe (see * Section 9.1 of [RFC2616]). Responses to this * method MUST NOT be cached.

This is an already existing directory, * so there is nothing to do for the server.

path too long

If a file is in memory, set all "stat" members and the membuf pointer of * output filep and return 1, otherwise return 0 and don't modify anything.

Try to find .htpasswd in requested directory.

PATH_INFO part of the URL

MacOS needs that. If we do not zero it, subsequent bind() will fail. * Also, all-zeroes in the socket address means binding to all addresses * for both IPv4 and IPv6 (INADDR_ANY and IN6ADDR_ANY_INIT).

Similar array as ssl_sw. These functions could be located in different * lib.

stdout read

After exec, all signal handlers are restored to their default * values, with one exception of SIGCHLD. According to * POSIX.1-2001 and Linux's implementation, SIGCHLD's handler will * leave unchanged after exec if it was set to be ignored. Restore * it to default action.

RFC2616 Section 10.3.2

EINVAL - Clock ID is unknown

non-ascii characters must be % encoded

No custom error page. Send default error page.

!_WIN32

end of list

Translate subject and issuer to a string

Number of variables available in var

current mask and opcode, overwritten by * memmove()

SSL called from an unknown thread: Create some thread index.

The maximum length of the path to the password file is limited

e.g., def from https://zlib.net/zlib_how.html

Number of variables stored in var

Only for memory statistics

64-bit length field

124

Writes PROPFIND properties for a collection element

13.3. everything but GET and HEAD (e.g. POST)

#define TCP_USER_TIMEOUT (18)

Parse authorization header

Not breaking the loop, process next websocket frame.

non-script files will not have sub-resources

Server side nonce check is valuable in all situations but one: * if the server restarts frequently, but the client should not see * that, so the server should accept nonces from previous starts.

Remote user name

Add data to buffer

96

While getaddrinfo on Windows will work with [::1], * getaddrinfo on Linux only works with ::1 (without []).

File is open for writing. If fclose fails, there was probably an * error flushing the buffer to disk, so the file on disk might be * broken. Delete it and return an error to the caller.

RFC2616 Section 10.4.9

Ignore errors. We can't call * mg_cry here anyway ;-)

RFC2616 Section 10.4.17

Is port SSL-ed

Out of range

Lua in-server module script: a CGI like script used to * generate * the * entire reply.

out: filename

!defined(NO_FILES)

Close so child gets an EOF.

Index block

'type cast' : conversion from 'int' to 'HANDLE' of greater size

Free the request buffer.

Other arguments must not be empty

Poll returned timeout (0).

Make a pointer to the free space int the buffer

fonts

to close

If a Lua background script has been configured, start it.

It could be the hixie draft version * (http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76).

HTTP 1.0 (and earlier) default is to close the connection

Allocate new block

What operating system is running

Head of the socket queue

may be null

no function prototype given: converting '()' to '(void)'

60

We are not in a tag yet.

regular end of content

first time reading from this connection

Windows is not standard-compliant, and vsnprintf() returns -1 if * buffer is too small. Also, older versions of msvcrt.dll do not have * _vscprintf(). However, if size is 0, vsnprintf() behaves correctly. * Therefore, we make two passes: on first pass, get required message * length. * On second pass, actually print the message.

Windows and Visual Studio Compiler

Read the rest of CGI output and send to the client

This is the heart of the Civetweb's logic. * This function is called when the request is read, parsed and validated, * and Civetweb must decide what action to take: serve a file, or * a directory, or call embedded function, etcetera.

Describes a string (chunk of memory).

Multiple protocols -> accept the last one.

Read the nonce from the response.

Substitute files have already been handled above.

ACL (RFC 3744)

User-defined data

must be a end of a word, but not a line

#define SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS 0x0001 ssl->s3->flags |= SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS;

First check if the port is the same (IPv4 and IPv6).

Space taken in buf

ws/wss client

For PHP

request is authorized or does not need authorization

mg_fopen will open a file either in memory or on the disk. * The input parameter path is a string in UTF-8 encoding. * The input parameter mode is MG_FOPEN_MODE_* * On success, either fp or membuf will be set in the output * struct file. All status members will also be set. * The function returns 1 on success, 0 on error.

Do an unsigned comparison in some conditions below

some intermediate directory has an index file

System info

illegal character for chunk length

HCP24: now check is it a substring or a full cookie name

RFC2616 Section 10.5 - Server Error 5xx

If SSL is loaded dynamically, dlopen/dlclose is required.

not consumed

assert(is_delete_request || (handler!=NULL));

everything is invalid for the moment (might change in the * future)

The support for duktape is still in alpha version state. * The name of this config option might change.

connected with IPv4

SSL loaded dynamically from DLL. * I put the prototypes here to be independent from OpenSSL source * installation.

Connections information

62

Step 3.1: Check if Lua is responsible.

assert(auth_handler != NULL);

Store the crypto library handle.

In contrast to OpenSSL, wolfSSL does not support certificate * chain files that contain private keys and certificates in * SSL_CTX_use_certificate_chain_file. * The CivetWeb-Server used pem-Files that contained both information. * In order to make wolfSSL work, it is split in two files. * One file that contains key and certificate used by the server and * an optional chain file for the ssl stack.

Sort and print directory entries

A http to https forward port has been specified, * but no https port to forward to.

The protocol is a comma separated list of names.

NOTE(lsm): order is important here. SSL certificates must * be initialized before listening ports. UID must be set last.

stderr read

all file related outputs have already been set to 0, just return

Write data to the IO channel - opened file descriptor, socket or SSL * descriptor. * Return value: * >=0 .. number of bytes successfully written * -1 .. timeout * -2 .. error

If there is a connection header from the client, obey

If no index file exists, restore directory path

in: request (must be valid)

SSL functions may fail and require to be called again: * see https://www.openssl.org/docs/manmaster/ssl/SSL_get_error.html * Here "func" could be SSL_connect or SSL_accept.

Callback for the master thread (type 0)

If only port is specified, bind to IPv4, INADDR_ANY

Time (wall clock) when connection was * established

Deallocate worker thread ID array

1 if in read_websocket

Free certificate memory

will not overflow

fclose failed. This might have different reasons, but a likely * one is "no space on disk", http 507.

max 64 headers

Important! When having connections with and without auth * would cause double free and then crash

92

+ MicroSoft extensions * https://msdn.microsoft.com/en-us/library/aa142917.aspx

since the return value is * int, we may not read more * bytes

Client sent an "Expect: xyz" header and xyz is not 100-continue.

We do not set a "Cache-Control" header here, but leave the default. * Since browsers do not send an OPTIONS request, we can not test the * effect anyway.

Use some UID as session context ID.

Set stop flag, so all threads know they have to exit.

11. File does not exist, or it was configured that it should be * hidden

the file is cached in memory

Read from file, exit the loop on error

civetweb should process the request

Use case sensitive compare function

State

Exit the loop if callback signals to exit (server side), * or "connection close" opcode received (client side).

RFC2616 Section 10.2.7

Lua rejected the new client

If send failed, wait before retry

current mask and opcode

See http://www.cplusplus.com/reference/cctype/

Worker threads take accepted socket from the queue

File name is relative to the currect document

Prepended CONFIG_ to avoid conflict with the * socket option typedef TCP_NODELAY.

Authorize against the opened passwords file. Return 1 if authorized.

_WIN32 / else

Use default of the standard

Handler for ws/wss (websocket) requests.

client context: loops must end

Append a pointer to the added string into the envp array

!NO_FILES

First store the length information in a text buffer.

Tag is still open

This included all leading \r and \n (isspace)

Step 1: Check websocket protocol version.

See #199 (https://github.com/civetweb/civetweb/issues/199)

Parent closes only one side of the pipes. * If we don't mark them as closed, close() attempt before * return from this function throws an exception on Windows. * Windows does not like when closed descriptor is closed again.

Request info

Connection info

RFC2616 Section 10.4.14

RFC2616 Section 10.4.11

actually, range requests don't play well with a pre-gzipped * file (since the range is specified in the uncompressed space)

Civetweb configuration parameters

No handler set - assume "OK"

The rest of the line is the status text

This following lines are just meant as a reminder to use the mg-functions * for memory management

RFC5842 Section 7.1

RFC2616 Section 10.3.3

No need to continue processing files once we have a * match, since nothing will reset it back * to 0.

The "file in memory" feature is a candidate for deletion. * Please join the discussion at * https://groups.google.com/forum/#!topic/civetweb/h9HT4CmeYqI

unknown content length

CGI needs it as REMOTE_USER

RFC2616 Section 10.2.2

Valid response

Next character after the port number

State as string

Tail of the socket queue

Calculate how much space is left in the buffer

We already know there is no more data buffered in conn->buf * but there is more available in the SSL layer. So don't poll * conn->client.sock yet.

NOTE(lsm): on QNX, poll() returns POLLRDNORM after the * successful poll, and POLLIN is defined as * (POLLRDNORM | POLLRDBAND) * Therefore, we're checking pfd[i].revents & POLLIN, not * pfd[i].revents == POLLIN.

HPUX defines socklen_t incorrectly as size_t which is 64bit on * Itanium. Without defining _XOPEN_SOURCE or _XOPEN_SOURCE_EXTENDED * the prototypes use int* rather than socklen_t* which matches the * actual library expectation. When called with the wrong size arg * accept() returns a zero client inet addr and check_acl() always * fails. Since socklen_t is widely used below, just force replace * their typedef with int. - DTL

No conn

It was defined for WEBDAV in RFC 3253, Sec. 3.6 * (https://tools.ietf.org/html/rfc3253#section-3.6), but seems * to be useful for REST in case a "GET request with body" is * required.

WEBDAV (RFC 2518)

!defined(NO_CGI) || defined(USE_LUA) || defined(USE_DUKTAPE)

Retrieve requested HTTP header multiple values, and return the number of * found occurences

stderr write

Build date

Should we stop event loop

process HTTPS connection

filep is initialized in mg_stat: all fields with memset to, * some fields like size and modification date with values

Destroy other context global data structures mutex

8. handle websocket requests

5.2.1. A callback will handle this request. All requests * handled * by a callback have to be considered as requests to a script * resource.

no can do

Loop over passwords file

13.1. Handle PROPFIND

!defined(NO_THREAD_NAME)

Step 7: Enter the read loop

11.3. MKCOL method

linked list of shared lua websockets

Read the first line of the script into the buffer

RFC2518 Section 10.5, RFC4918 * Section 11.4

Check after term

Substitute file found. Copy stat to the output, then * check if the file is a script file

5. interpret the url to find out how the request must be handled

Start worker threads

relative uri

Don't use mg_cry here, but only a trace, since this is * a typical case. It will occur for every directory * without a password file.

Close, if civetweb framework needs to close

HPUX 11 does not have monotonic, fall back to realtime

No more data left to read

Start WinSock for Windows

Increase priority of the master thread

Windows specific

5.2.2. No callback is responsible for this request. The URI * addresses a file based resource (static content or Lua/cgi * scripts in the file system).

Get the next step of both random number generators.

RFC2616 Section 10.2.6

Un-initialize this library.

Wait for a thread to finish.

DTL add for SO_EXCLUSIVE

Add all headers as HTTP_* variables

NOTE(lsm): this enum shoulds be in sync with the config_options below.

conn is assumed to be valid in this internal function

not OPENSSL_API_1_1

Test for different ways to format this string

Allocate space to hold websocket payload

Not connected

URI: /path_to_script/script.cgi/path_info

Step 3: No callback. Check if Lua is responsible.

For flockfile() on Linux

Implementation of API function for HTTP clients

Mark the queue as advanced

END: CLOCK_PROCESS

Total size of data in a buffer

9b. This request is either for a static file or resource handled * by a script file. Thus, a DOCUMENT_ROOT must exist.

Handler for authorization requests

first try to find an existing handler

If peem is NULL and conn->ctx->callbacks.init_ssl is not, * refresh_trust still can not work.

Request is directed to this server - full name match.

the value is not required

No content

+ 11 methods from RFC 3253

7. check if there are request handlers for this uri

END: CLOCK_THREAD

Set the thread name for debugging purposes in Visual Studio * http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx

Set TCP keep-alive. This is needed because if HTTP-level * keep-alive * is enabled, and client resets the connection, server won't get * TCP FIN or RST and will keep the connection open forever. With * TCP keep-alive, next keep-alive handshake will figure out that * the client is down and will close the server end. * Thanks to Igor Klopov who suggested the patch.

Substitute file is a regular file

out: put/delete a file?

Check for a valid http method

The server must only return one value from this list.

Windows happily opens files with some garbage at the end of file name. * For example, fopen("a.cgi ", "r") on Windows successfully opens * "a.cgi", despite one would expect an error back. * This function returns non-0 if path ends with some garbage.

If name=" is found, search for the closing "

Read new data

There are three ways to encode data from a HTML form: * 1) method: GET (default) * The form data is in the HTTP query string. * 2) method: POST, enctype: "application/x-www-form-urlencoded" * The form data is in the request body. * The body is url encoded (the default encoding for POST). * 3) method: POST, enctype: "multipart/form-data". * The form data is in the request body of a multipart message. * This is the typical way to handle file upload from a form.

If the boundary is already in the buffer, get the address, * otherwise next will be NULL.

GET request: form data is in the query string.

Get the mandatory name="..." part of the Content-Disposition * header.

No query string.

Copy boundary string to variable "boundary"

No body data, but not a GET request. * This is not a valid form request.

Store the content of the buffer.

Read body data and split it in keys and values. * The encoding is like in the "GET" case above: a=1&b&c=3&c=4. * Here we use "POST", and read the data from the request body. * The data read on the fly, so it is not required to buffer the * entire request in memory before processing it.

Malformed request (the filename field is optional, but if * it exists, it needs to be terminated correctly).

Malformed request

Unknown Content-Type

Call callback

}

All parts handled

We must do a binary search here, not a string search, since the buffer * may contain '\x00' bytes, if binary data is transferred.

Copyright (c) 2016-2017 the Civetweb developers * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE.

RFC 2616 Sec. 2.2 defines a list of allowed * separators, but many of them make no sense * here, e.g. various brackets or slashes. * If they are used, probably someone is * trying to attack with curious hand made * requests. Only ; , space and tab seem to be * reasonable here. Ignore everything else.

End of handle_form.inl

If the boundary is quoted, trim the quotes

Next, we need to get the part header: Read until \r\n\r\n

TODO: Create a function to get "all_data_read" from * the conn object. All data is read if the Content-Length * has been reached, or if chunked encoding is used and * the end marker has been read, or if the connection has * been closed.

RFC 2046 permits the boundary string to be quoted.

Store the content to a file

if (field_storage == FORM_FIELD_STORAGE_READ) {

In theory, it could be possible that someone crafts * a request like name=filename=xyz. Check if name and * filename do not overlap.

Log error message and stop parsing the form data.

Skip \r\n\r\n

There has to be a BOUNDARY definition in the Content-Type header

No data

name= without quotes is also allowed

Try the same without quotes

Out of memory

In every "field_found" callback we ask what to do with the * data ("field_storage"). This could be: * FORM_FIELD_STORAGE_SKIP (0) ... ignore the value of this field * FORM_FIELD_STORAGE_GET (1) ... read the data and call the get * callback function * FORM_FIELD_STORAGE_STORE (2) ... store the data in a file * FORM_FIELD_STORAGE_READ (3) ... let the user read the data * (for parsing long data on the fly) * (currently not implemented) * FORM_FIELD_STORAGE_ABORT (flag) ... stop parsing

Split data in a=1&b=xy&c=3&c=4 ...

The form data is in the request body data, encoded in key/value * pairs.

avoid warning

Must not be smaller than ~900 - see sanity check

read error

Loop to read values larger than sizeof(buf)-keylen-2

Log error message and skip this field.

Remove from the buffer

The entire data has already been loaded, so there is no nead to * call mg_read. We just need to split the query string into key-value * pairs.

init here, to a avoid a false positive "uninitialized variable used" warning

Equivalent to "upload" callback of "mg_upload".

Every part must end with \r\n, if there is another part. * The end of the request has an extra --

End of the request

According to the RFC, every part has to have a header field like: * Content-Disposition: form-data; name="..."

It could be somethingname= instead of name=

Stop parsing the request

Proceed to next entry

Skip all spaces between MULTIPART/FORM-DATA; and BOUNDARY=

Find boundary

Content-Type: application/octet-stream

Get the optional filename="..." part of the Content-Disposition * header.

Set "towrite" to the number of bytes available * in the buffer

TODO: Create a function to get "all_data_read" * from the conn object. All data is read if the * Content-Length has been reached, or if chunked * encoding is used and the end marker has been * read, or if the connection has been closed.

This callback will deliver partial contents

It could be somethingfilename= instead of filename=

stored successfully

The form data is in the request body data, encoded as multipart * content (see https://www.ietf.org/rfc/rfc1867.txt, * https://www.ietf.org/rfc/rfc2388.txt).

Call callback for new field

From RFC 2046: * Boundary delimiters must not appear within the * encapsulated material, and must be no longer * than 70 characters, not counting the two * leading hyphens.

Subtract the boundary length, to deal with * cases the boundary is only partially stored * in the buffer.

If filename=" is found, search for the closing "

Should we use a config file ?

Initialize the dialog elements

Errno will still hold the error from fopen.

invalid number

Show usage if -h or --help options are specified

option set correctly

Trim additional spaces between option name and value - then * (line+j) contains the option value

Set by init_system_info()

Get content of input line

Dialog proc for input dialog

Attach menu to the status bar

Run this app as agent

UNC path, e.g. \\server\dir

initWithTitle:[NSString stringWithFormat:@"%s", server_name]

Make extra verification for certain options

mg_start copies all options to an internal buffer. * The options data field here is not required anymore.

This should also be sufficient for "realpath", according to * http://man7.org/linux/man-pages/man3/realpath.3.html, but in * reality it does not seem to work.

strip UTF-8 BOM

Disable deprecation warning in VS2005

Required for some functions (tray icons, ...)

invalid boolean

defined(_WIN32) && !defined(__SYMBIAN32__) - WINDOWS / UNIX include \ block

For __MINGW32/64_MAJOR/MINOR_VERSION define

Setup signal handler: quit on Ctrl-C

integer number >= 0, e.g. number of threads

defined(_WIN32) && !defined(__SYMBIAN32__) - WINDOWS / UNIX include \ block

If option is already set and it is an absolute path, leave it as it is -- it's already absolute.

for taskbar creation

Remove user

Edit passwords file: Remove user, if -R option is specified

WINDOWS / UNIX include block

Update config based on command line arguments

Advance to next character

No config file set. Path to exe found in arg[0]. * Use default file name next to the executable.

Required for unit testing

If value is the same as default, skip it

Win32 has a small GUI. * Define some GUI elements and Windows message handlers.

Set by init_server_name()

backup config file

Start option -I: * Show system information and exit * This is very useful for diagnosis.

<inttypes.h> wants this for C++

Do not open a password dialog, if the username is empty

Option already set. Overwrite

LPARAM pointer passed to WM_INITDIALOG

any text

Add status bar menu

Make sure we have absolute paths for files and directories

Initialize user data

Add version menu item

Invalid esc sequence

Load config file settings first

Line is only \

Add configuration menu item

Separator

Start Civetweb

Option not set yet. Add new option

Create the dialog

Loop over the lines in config file

Ignore empty lines and comments

alternative: SendMessage(hDlg, WM_COMMAND, ID_RESET_FILE, 0);

Set dialog handle for the caller

C++ wants that for INT64_MAX

Dialog proc for password dialog

Get handle of input line

_WIN32

lines of text, separated by carriage return line feed

Use same defines as in civetweb.c before including system headers.

Add quit menu item

Terminate the string - then the string at (line+i) contains the * option name

Copyright (c) 2013-2017 the Civetweb developers * Copyright (c) 2004-2013 Sergey Lyubka * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE.

Handle command line flags. They override config file and default settings.

Create a password suggestion

Absolutize the path, and set the option

Set by start_civetweb()

invalid ESC sequence

Call Lua with additional CivetWeb specific Lua functions, if -L option * is specified

Only allow one instance of this dialog to be open.

list of text items, separated by ,

Add delegate to process menu item actions

Add connect menu item

Return the WM_QUIT value.

Otherwise: CivetWeb can work without a config file

Skip spaces, \r and \n at the end of the line

ignore result

boolean value, yes or no

Edit passwords file: Add user or change password, if -A option is * specified

Advance mbl characters (+1 is below)

unknown option

try alternate config file

Reload field with this ID

If mg_start fails, it returns NULL

Window proc for taskbar icon

no break

Not absolute. Use the directory where civetweb executable lives be the relative directory for everything. Extract civetweb executable directory into path.

Load current string

Dialog proc for settings dialog

We've just sent our own quit message, with proper hwnd.

Call Duktape, if -E option is specified

Modify password

Set by process_command_line_arguments()

for tdm-gcc so we can use getconsolewindow

Passed to mg_start() by start_civetweb()

valid characters are 32 to 126

Set option

list of patterns, separated by |

For PATH_MAX on linux

Open the config file

For fseeko(), ftello()

The first command line parameter is a config file name.

Main loop should exit

Input dialog is not empty.

If we're under MacOS and started by launchd, then the second argument is process serial number, -psn_..... In this case, don't process arguments at all.

E.g. X:\dir

This is an input dialog

!CONFIG_FILE

Store hWnd in a parameter accessible by the parent, so we can * bring this window to front if required.

Find the space character between option name and value

Make buffer available for input dialog

In case this causes a problem, disable the warning: * #pragma GCC diagnostic ignored "-Wimplicit-function-declaration" * #pragma clang diagnostic ignored "-Wimplicit-function-declaration"

Text boxes for files have "..." buttons to open file browser. These buttons have IDs that are ID_FILE_BUTTONS_DELTA higher than associated text box ID.

Run the app

Invalid multi byte character

read all configurations from a config file

18 bytes

No config file set. No path in arg[0] found. * Use default file name in the current path.

Check whether option is already set

Init dialog with active settings

There is no input line in this dialog.

If config file was set in command line and open failed, die.

Create config file if it is not present yet

Get dialog parameters

Failed to open the file. Keep errno for the caller.

Use 64-bit file offsets by default

All dynamically created text boxes for options have IDs starting from ID_CONTROLS, incremented by one.

Set dialog name

Add user

This option is evaluated by main.c, not civetweb.c - just skip it * and return OK

0xffff5bb1

0xd4ef3085

accumulate block

0x8771f681

0xfffa3942

Define storage for little-endian or both types of CPUs.

Let [abcd k s t] denote the operation a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s).

0xd9d4d039

Let [abcd k s t] denote the operation a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s).

message length in bits, lsw first

Copyright (C) 1999, 2000, 2002 Aladdin Enterprises. All rights reserved. This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. L. Peter Deutsch ghost@aladdin.com

0xf7537e82

(dynamic only)

32-bit word

Process full blocks.

0xf4d50d87

data are properly aligned, a direct assignment is possible

Append a string to the message.

0xe8c7b756

0xc040b340

0xc4ac5665

0xfd987193

0xffeff47d

0xf6bb4b60

Define storage only for big-endian CPUs.

0xfe2ce6e0

0xe6db99e5

$Id: md5.h,v 1.4 2002/04/13 19:20:28 lpd Exp $

0xfc93a039

0xa8304613

Do the following 16 operations.

(static only)

cast through a (void *) should avoid a compiler warning, see https://github.com/bel2125/civetweb/issues/94#issuecomment-98112861

dynamic little-endian

0xf61e2562

0xab9423a7

0xc33707d6

0xf4292244

Save the length before padding.

* On big-endian machines, we must arrange the bytes in the * right order.

Process a final partial block.

0xd8a1e681

0xe7d3fbc8

0x98badcfe

0xc1bdceee

0xeaa127fa

0xa4beea44

0x8f0ccc92

8-bit byte

0xd62f105d

Update the message length.

0xa679438e

Let [abcd k s i] denote the operation a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s).

Pad to 56 bytes mod 64.

0xd76aa478

* This an amalgamation of md5.c and md5.h into a single file * with all static declaration to reduce linker conflicts * in Civetweb. * * The MD5_STATIC declaration was added to facilitate static * inclusion. * No Face Press, LLC

end extern "C"

digest buffer

0xf57c0faf

Round 4.

End of md5.inl

0xbebfbc70

Round 2.

Process an initial partial block.

Let [abcd k s i] denote the operation a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s).

Round 3.

dynamic big-endian

Append the length.

0xeb86d391

0x895cd7be

0x8b44f7af

0xfd469501

$Id: md5.c,v 1.6 2002/04/13 19:20:28 lpd Exp $

0xbd3af235

0x85845dd1

Round 1.

[64]

Initialize the algorithm.

0xe9b6c7aa

0xfde5380c

Finish the message and return the digest.

0x8d2a4c8a

Define the state of the MD5 Algorithm.

* On little-endian machines, we can process properly aligned * data without copying it.

0xefcdab89

md5_INCLUDED

not aligned

0xa9e3e905

little-endian

0xa3014314

big-endian

0xfcefa3f8

Then perform the following additions. (That is increment each of the four registers by the value it had before this block was started.)

add function conn.read

call the table "civetweb"

subfolder "conn.http_headers"

1 = nargs

Add "conn" object

Add "civetweb" object

0 = nargs

call the table "conn"

probably never reached, but satisfies static code analysis

add function conn.write

duk_push_global_stash(duk_ctx); duk_get_prop_string(duk_ctx, -1, civetweb_conn_id); conn = (struct mg_connection *)duk_to_pointer(duk_ctx, -1);

Note: This is only experimental support, so the API may still change.

ignore result

add string conn.r...

Create Duktape interpreter state

create a new table/object ("conn")

For evaluation purposes, currently only "send" is supported. * All other ~50 functions will be added later.

Script is called "protected" (duk_peval_file), so script errors should * never yield in a call to this function. Maybe calls prior to executing * the script could raise a fatal error.

This file is part of the CivetWeb web server. * See https://github.com/civetweb/civetweb/ * (C) 2015-2017 by the CivetWeb authors, MIT license.

Alternative: redefine a new, clean API from scratch (instead of using mg), * or at least do not add problematic functions.

End of mod_duktape.inl

mg.include: Include another .lp file

No truncation check for ebuf

Forward declarations

just one text: send it to all client

client id, opcode string and message text

mg.set_timeout for websockets

Variable found: return value to Lua

Get connection info for connection idx

path_type==NULL is the legacy use case with 1 argument

Do not closesocket(*psock); here, close it in __gc

Return the current "keep_alive" state. This may be false, even it * keep_alive(true) has been called.

Assume the script does not support keep_alive. The script may change this * by calling mg.keep_alive(true).

Register mg module

Lua server pages store the depth of mg.include, in order * to detect recursions and prevent stack overflows.

mg.write for websockets

This function may be called with one parameter (boolean) to set the keep_alive state. Or without a parameter to just query the current keep_alive state.

Get option according to argument

Syntax error or OOM. Error message is pushed on * stack.

mg.get_var

Stack of includes

Allocate dynamically, so there is no internal limit for get_var

"relative" = file name is relative to the * currect document

The civetweb internal random number generator will generate * a 64 bit random number.

remote_ip is deprecated, use remote_addr instead

mg.redirect: Redirect the request (internally).

mg.base64_encode

Preload

client id, opcode number and message text

lua_Number may be used as 52 bit integer

zero or one return value

mg.write: Send data to the client

Error when loading the file (e.g. file not found, * out of memory, ...)

This file is part of the CivetWeb web server. * See https://github.com/civetweb/civetweb/

Execute a plain Lua script.

Correct number of arguments

mg.get_info

Register default mg.onerror function

mg.send_file

Remove from ws connection list.

mmap failed

The script file is loaded, now call it

File not found or not accessible

mg.get_time

opcode number and message text

call add

reg_int64: content_length

Get info according to argument

call mg.write()

Export mg.request_info

"virtual" = relative to document root.

mg.set_interval for websockets

Store script name and increment depth

Get context info for server context

Store context in the registry

no arguments

mg.url_decode

Silently stop processing chunks.

client id and message text

UUID library and function pointer

mg.keep_alive: Allow Lua pages to use the http keep-alive mechanism

opcode string and message text

add ws to list

"absolute" = file name is relative to the * webserver working directory * or it is absolute system path.

mg.get_response_code_text

handle_lsp_request returned an error code, meaning an error * occured in the included page and mg.onerror returned non-zero. * Stop processing.

mg_fopen opens the file and sets the size accordingly

Get context

mg.cry: Log an error. Default value for mg.onerror.

End of mod_lua.inl

Export connection specific info

mg.random - might be better than math.random on some systems

Lua "number" is a IEEE 754 double precission float: * https://en.wikipedia.org/wiki/Double-precision_floating-point_format * Thus, mask with 2^53-1 to get an integer with the maximum * precission available.

mg.md5

mg.get_mime_type

mg.uuid

Get context info for NULL context

Success loading chunk. Call it.

TODO (mid): Check if list entry and Lua state needs to be deleted * (see websocket_close).

mg.url_encode

mg.read: Read data from the client (e.g., from a POST request)

Get LSP include history table

Error when executing the script

Lua state is ready to use

Syntax error

init ws list element

Map file in memory (size is known).

Script executed

Get system info

We're not sending HTTP headers here, Lua page must do it.

name only used for debugging

inc ref count

Methods and meta-methods supported by the object returned by connect. * For meta-methods, see http://lua-users.org/wiki/MetatableEvents

reg_conn_function(L, "send_file", lsp_send_file, conn);

If the first argument is a number, convert it to the corresponding text.

Lua uses 1 based index, C uses 0 based index

errors as strint return value

check if ws already in list

mg.get_cookie

lock list (mg_context global)

lua_close(L); must be done somewhere else

mg.get_option

Add padding and return the message digest.

SHA-1 in C By Steve Reid <sreid@sea-to-sky.net> 100% Public Domain ----------------- Modified 7/98 By James H. Brown <jbrown@burgoyne.com> Still 100% Public Domain Corrected a problem which generated improper hash values on 16 bit machines Routine SHA1Update changed from void SHA1Update(SHA_CTX* context, unsigned char* data, unsigned int len) to void SHA1Update(SHA_CTX* context, unsigned char* data, unsigned long len) The 'len' parameter was declared an int which works fine on 32 bit machines. However, on 16 bit machines an int is too small for the shifts being done against it. This caused the hash function to generate incorrect values if len was greater than 8191 (8K - 1) due to the 'len << 3' on line 3 of SHA1Update(). Since the file IO in main() reads 16K at a time, any file 8K or larger would be guaranteed to generate the wrong hash (e.g. Test Vector #3, a million "a"s). I also changed the declaration of variables i & j in SHA1Update to unsigned long from unsigned int for the same reason. These changes should make no difference to any 32 bit implementations since an int and a long are the same size in those environments. -- I also corrected a few compiler warnings generated by Borland C. 1. Added #include <process.h> for exit() prototype 2. Removed unused variable 'j' in SHA1Final 3. Changed exit(0) to return(0) at end of main. ALL changes I made can be located by searching for comments containing 'JHB' ----------------- Modified 8/98 By Steve Reid <sreid@sea-to-sky.net> Still 100% public domain 1- Removed #include <process.h> and used return() instead of exit() 2- Fixed overwriting of finalcount in SHA1Final() (discovered by Chris Hall) 3- Changed email address from steve@edmweb.com to sreid@sea-to-sky.net ----------------- Modified 4/01 By Saul Kravitz <Saul.Kravitz@celera.com> Still 100% PD Modified to run on Compaq Alpha hardware. ----------------- Modified 07/2002 By Ralph Giles <giles@ghostscript.com> Still 100% public domain modified for use with stdint types, autoconf code cleanup, removed attribution comments switched SHA1Final() argument order for consistency use SHA1_ prefix for public api move public api to sha1.h

little endian / intel byte order

I got the idea of expanding during the round function from SSLeay

Endian independent

4 rounds of 20 operations each. Loop unrolled.

Should cause a SHA1_Transform()

blk0() and blk() perform the initial expand.

Wipe variables

SHA1 initialization constants

Copy context->state[] to working vars

Test Vectors (from FIPS PUB 180-1) "abc" A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1 A million repetitions of "a" 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F

Hash a single 512-bit block. This is the core of the algorithm.

SHA1Init - Initialize new context

(R0+R1), R2, R3, R4 are the different operations used in SHA1

Must use an aligned, read/write buffer

Add the working vars back into context.state[]

End of sha1.inl

/ capacity of current token

/ stores number of special character codes

Tokenizer_print(tok);

set metatable:

set __tostring metamethod

/ stores next token, if already determined

/ pointer to current token

* LuaXML License LuaXml is licensed under the terms of the MIT license reproduced below, the same as Lua itself. This means that LuaXml is free software and can be used for both academic and commercial purposes at absolutely no cost. Copyright (C) 2007-2013 Gerald Franz, eludi.net Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

/ stores current read position

/ stores size of string to be tokenized

read elements

register default codes:

/ stores code table for special characters

/ stores current read context

/ stores string to be tokenized

parse tag header

new tag found

/ size of current token

--- internal tokenizer -------------------------------------------

void Tokenizer_print(Tokenizer* tok) { printf(" @%u %s\n", tok->i, !tok->m_token ? "(null)" : (tok->m_token[0]==ESC)?"(esc)" : (tok->m_token[0]==OPN)?"(open)": (tok->m_token[0]==CLS)?"(close)" : tok->m_token); fflush(stdout); }

/ stores currently allocated capacity for special character codes

regular attribute

this tag has no content, only attributes

trim whitespace

strip comments

--- local variables ----------------------------------------------

/ size of next token

interpet CDATA

parse tag and content: use index 0 for storing the tag

--- auxliary functions -------------------------------------------

strip meta information

--- public methods -----------------------------------------------

previous tag is over pop current table

Lua 5.1 detected

not supported

This header is intended to support Lua 5.1, Lua 5.2 and Lua 5.3 in the same * C source code.

Lua 5.2 detected

Must use luaL_newstate() for 64 bit target

Copyright (c) 2015-2017 the Civetweb developers * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE.

#ifndef CIVETWEB_LUA_H

Lua 5.3 detected

Shared helper to generate DUK_OPT_xxx and DUK_USE_xxx documentation. XXX: unfinished placeholder

Add a header snippet for detecting presence of DUK_OPT_xxx feature options which will be removed in Duktape 2.x.

Add a header snippet for providing a __OVERRIDE_DEFINES__ section.

XXX: unsigned constants?

Globals holding scanned metadata, helper snippets, etc

verbatim text for the entire line

Add original snippets. This fills in the required nodes recursively.

print('#snippet ' + sub_fn)

already present

Assume these provides come from outside.

Feature selection, system include, Date provider Most #include statements are here

Remaining tags in alphabetic order

Automatic DUK_OPT_xxx feature option handling

key is known

Byte order and alignment defines are allowed to be missing, a fill-in will handle them. This is necessary because for some architecture byte order and/or alignment may vary between targets and may be software configurable.

integer value

Figure out fill-ins by looking for snippets not in original list and without any unserialized dependent nodes.

duk_config.h generation

print(repr(graph)) print(repr(snlist)) print('Resolved helper defines: %r' % resolved)

Detect and reject 'fast math'

Helper for building a text file from individual lines, injected files, etc. Inserted values are converted to Snippets so that their provides/requires information can be tracked. When non-C outputs are created, these will be bogus but ignored.

Don't allow e.g. DUK_USE_ which results from matching DUK_USE_xxx

NOTE: careful with Python equality, e.g. "0 == False" is true.

Metadata to scan from config files.

Generate a duk_config.h where platform, architecture, and compiler are all either autodetected or specified by user. Autodetection is based on a configured list of supported platforms, architectures, and compilers. For example, platforms.yaml defines the supported platforms and provides a helper define (DUK_F_xxx) to use for detecting that platform, and names the header snippet to provide the platform-specific definitions. Necessary dependencies (DUK_F_xxx) are automatically pulled in. Automatic "fill ins" are used for mandatory platform, architecture, and compiler defines which have a reasonable portable default. This reduces e.g. compiler-specific define count because there are a lot compiler macros which have a good default.

Development time helper: add DUK_ACTIVE which provides a runtime C string indicating what DUK_USE_xxx config options are active at run time. This is useful in genconfig development so that one can e.g. diff the active run time options of two headers. This is intended just for genconfig development and is not available in normal headers.

Default value is false, and caller has emitted an unconditional #undef, so don't emit a duplicate

Platform, architecture, compiler fillins. These are after all detection so that e.g. DUK_SPRINTF() can be provided by platform or compiler before trying a fill-in.

Main

sort under primary tag

Compiler files must provide at least these (additional checks in validate_compiler_file()). Fill-ins provide missing optionals.

Header snippet representation: lines, provides defines, requires defines.

signal to fillin

print('Tags: %r' % use_tags_list)

must be #define'd

Compatibility with Duktape 1.3

compiling Duktape from a single source file (duktape.c) version compiling Duktape (not user application) artifact, include guard

Forced options from multiple sources are gathered into a shared list so that the override order remains the same as on the command line.

Avoid ambiguous hex escapes

Snippet provides it's own require; omit

print('config option %s not covered by manual snippets, emitting default automatically' % k)

C string value

Platform files must provide at least these (additional checks in validate_platform_file()). Fill-ins provide missing optionals.

shallow copy

Architecture files must provide at least these (additional checks in validate_architecture_file()). Fill-ins provide missing optionals.

Generate a duk_config.h header with platform, compiler, and architecture either autodetected (default) or specified by user. Support for autogenerated DUK_OPT_xxx flags is also selected by user.

Preferred tags first

snippet list

graph[A] = [ B, ... ] <-> B, ... provide something A requires.

x is a Snippet

Helper headers snippets.

lines of text and/or snippets map from define to 'True' for now map from define to 'True' for now

strip last newline to avoid empty line

This is a fallback in case config option metadata is wrong.

byteorder provided by all architecture files alignment provided by all architecture files packed tval provided by all architecture files

print('Autoscanning snippet: %s' % fn)

for printing only

Emit a default #define / #undef for an option based on a config option metadata node (parsed YAML doc).

Object layout

Careful with order, snippet may self-reference its own defines in which case there's no outward dependency. (This is not 100% because the order of require/provide matters and this is not handled now.) Also, some snippets may #undef/#define another define but they don't "provide" the define as such. Such redefinitions are marked "/* redefine */" in the snippets. They're best avoided (and not currently needed in Duktape 1.4.0).

Helpers for duk_config.h generation

must be #define'd may be #undef'd, as long as provided may be #undef'd, as long as provided may be #undef'd, as long as provided

Snippet may have further unresolved provides; add recursively

For some options like DUK_OPT_PACKED_TVAL the default comes from platform definition.

Date provider snippet is after custom header and overrides, so that the user may define e.g. DUK_USE_DATE_NOW_GETTIMEOFDAY in their custom header.

If manually-edited snippets don't #define or #undef a certain config option, emit a default value here. This is useful to fill-in for new config options not covered by manual snippets (which is intentional).

position where to emit DUK_F_xxx dependencies

print('Resolving %r' % k)

Miscellaneous helpers

If a related feature option exists, it can be used to force enable/disable the target feature. If neither feature option (DUK_OPT_xxx or DUK_OPT_NO_xxx) is given, revert to default.

print('Deleting temporary directory: %r' % dirname)

at least one other node provides 'k'

Preferred tag order for generated C header files.

Add automatic DUK_OPT_XXX and DUK_OPT_NO_XXX handling for backwards compatibility with Duktape 1.2 and before.

DUK_SETJMP, DUK_LONGJMP, DUK_JMPBUF_TYPE are optional, fill-in provides if none defined.

for trailing newline

Forced options, last occurrence wins (allows a base config file to be overridden by a more specific one).

DUK_F_xxx snippets

emit tag heading only if there are subsections

Number types

print('REQUIRES: %r' % m)

verbatim value

print('Effective tag order: %r' % tags)

DUK_F_UCLIBC is special because __UCLIBC__ is provided by an #include file, so the check must happen after platform includes. It'd be nice for this to be automatic (e.g. DUK_F_UCLIBC.h.in could indicate the dependency somehow).

Emit forced options. If a corresponding option is already defined by a snippet above, #undef it first.

DLL build affects visibility attributes on Windows but unfortunately cannot be detected automatically from preprocessor defines or such. DLL build status is hidden behind DUK_F_DLL_BUILD and there are two ways for that to be set: - Duktape 1.3 backwards compatible DUK_OPT_DLL_BUILD - Genconfig --dll option

Preferred tag order for option documentation.

XXX: check that YAML parses

Pretty print a debugger command.

Duktape internal class numbers, must match C headers

Write a string into a buffer interpreting codepoints U+0000...U+00FF * as bytes. Drop higher bits.

absFn -> true

Errors

true

We shouldn't come here, but if we do, JSON is a reasonable default.

Could emit a 'debug-value' event here, but that's not necessary because the receiver will just collect statistics which can also be done using the finished message.

There is no close() or destroy() for a passthrough stream, so just close the outputParser which will cancel timers etc.

Raw bytes Unicode string

Still waiting for version identification to complete.

2-byte string

undefined

* JSON debug proxy

msg.varname is a proper Unicode strings here, and needs to be converted into a protocol string (U+0000...U+00FF).

new object, old may be in circulation for a while

list of command names, merged client/target

XXX: normalize last newline (i.e. force a newline if contents don't end with a newline)?

accumulate data accumulated message until EOM

A PutVar call quite possibly changes the local variables so always re-read locals afterwards. We don't need to wait for PutVar to complete here; the requests will pipeline automatically and be executed in order.

2-byte buffer

'./foo/bar.js' -> 'foo/bar.js'

whole

Commands initiated by Duktape

Not all streams will emit this.

Pretty print a dvalue. Useful for dumping etc.

Could also check for an empty request queue, but that's probably too strict?

Technically we should wait for each delbreak reply but because target processes the requests in order, it doesn't matter.

Protocol version handling. When dumping an output stream, the caller gives a non-null protocolVersion so we don't read one here.

Up-to-date list of breakpoints on target

console.log(JSON.stringify(msg));

Duktape heaphdr type constants, must match C headers

* Debugger implementation * * A debugger instance communicates with the debug target and maintains * persistent debug state so that the current state can be resent to the * socket.io client (web UI) if it reconnects. Whenever the debugger state * is changed an event is generated. The socket.io handler will listen to * state change events and push the necessary updates to the web UI, often * in a rate limited fashion or using a client pull to ensure the web UI * is not overloaded. * * The debugger instance assumes that if the debug protocol connection is * re-established, it is always to the same target. There is no separate * abstraction for a debugger session.

error

Decode and normalize source file contents: UTF-8, tabs to 8, * CR LF to LF.

* Command line parsing and initialization

"notify" can be a string or "true"

Shouldn't come here.

4-byte signed integer

For the unquoted version we don't need to escape single or double quotes.

unsigned

msg.input is a proper Unicode strings here, and needs to be converted into a protocol string (U+0000...U+00FF).

nop: no callback

https://github.com/ryanmcgrath/wrench-js

varvalue is JSON parsed by the web UI for now, need special string encoding here.

Command line options (defaults here, overwritten if necessary)

truncate higher bits

No actual requests sent by the target right now (just notifys).

Encode an ordinary Unicode string into a dvalue compatible format, i.e. * into a byte array represented as codepoints U+0000...U+00FF. Concretely, * encode with UTF-8 and then represent the bytes with U+0000...U+00FF.

console.log('Received json proxy input line: ' + line.toString('utf8'));

* Miscellaneous helpers

indicate 'v' is actually set

Dump effective options. Also provides a list of option names.

Although the underlying transport may not have a close() or destroy() method or even a 'close' event, this method is always available and will generate a 'transport-close'. The caller is responsible for closing the underlying stream if that is necessary.

A byline-parser is simple and good enough for now (assume compact JSON with no newlines).

override

update run state now that we're paused

duk_tval number, any IEEE double decode into hex big endian ieee double

just trigger a sync, gets rate limited

Marker objects for special protocol values

Fetch basic info right away

An eval call quite possibly changes the local variables so always re-read locals afterwards. We don't need to wait for Eval to complete here; the requests will pipeline automatically and be executed in order.

Commands initiated by the debug client (= us)

res.status(200).json(val);

raw identification string

Create debugger and web UI singletons, tie them together and start them.

* Debug protocol parser * * The debug protocol parser is an EventEmitter which parses debug messages * from an input stream and emits 'debug-message' events for completed * messages ending in an EOM. The parser also provides debug dumping, stream * logging functionality, and statistics gathering functionality. * * This parser is used to parse both incoming and outgoing messages. For * outgoing messages the only function is to validate and debug dump the * messages we're about to send. The downside of dumping at this low level * is that we can't match request and reply/error messages here. * * http://www.sitepoint.com/nodejs-events-and-eventemitter/

Pretty print a dvalue string (bytes represented as U+0000...U+00FF) * for UI usage without quotes.

Loose matching is tempting but counterproductive: filenames must match 1:1 between the debug client and the debug target for e.g. breakpoints to work as expected. Note that a breakpoint may be assigned by selecting a file from a dropdown populated by scanning the filesystem for available sources and there's no way of knowing if the debug target uses the exact same name.

web UI singleton transport connection to target dummy passthrough for message dumping parser for incoming debug messages parser for outgoing debug messages (stats, dumping)

// This fails with "RangeError: Maximum call stack size exceeded" for some // reason, so use a much slower variant. for (i = 0, n = buf.length; i < n; i++) { cp[i] = buf[i]; } return String.fromCharCode.apply(String, cp);

We require a destroy() method from the actual target stream

Debug protocol integer

shift forces unsigned

Send a status request to trigger a status notify, result is ignored: target sends a status notify instead of a meaningful reply

See doc/debugger.rst for format description.

Pretty print a dvalue string (bytes represented as U+0000...U+00FF) * for UI usage. Try UTF-8 decoding to get a nice Unicode string (JSON * encoded) but if that fails, ensure that bytes are encoded transparently. * The result is a quoted string with a special quote marker for a "raw" * string when UTF-8 decoding fails. Very long strings are optionally * clipped.

console.dir(argv);

Intentional invalid command

When we fall back to representing bytes, indicate that the string is "raw" with a 'r"' prefix (a somewhat arbitrary convention). U+0022 = ", U+0027 = '

number (IEEE double), big endian

We want the fileMap to contain the filename relative to the search dir root.

Initial debugger connection

Represented signed 32-bit integers as plain integers. Debugger code expects this for all fields that are not duk_tval representations (e.g. command numbers and such).

Right now bytecode is a string containing a direct dump of the bytecode in target endianness. Decode here so that the web UI doesn't need to.

msg.varname and msg.varvalue are proper Unicode strings here, they need to be converted into protocol strings (U+0000...U+00FF).

Note: typeof null === 'object', so null special case explicitly

Parse complete dvalues (quite inefficient now) by trial parsing. Consume a value only when it's fully present in 'buf'. See doc/debugger.rst for format description.

0x80...0xbf: integers 0-63

pointer

* Source file manager * * Scan the list of search directories for Ecmascript source files and * build an index of them. Provides a mechanism to find a source file * based on a raw 'fileName' property provided by the debug target, and * to provide a file list for the web UI. * * NOTE: it's tempting to do loose matching for filenames, but this does * not work in practice. Filenames must match 1:1 with the debug target * so that e.g. breakpoints assigned based on filenames found from the * search paths will match 1:1 on the debug target. If this is not the * case, breakpoints won't work as expected.

not cached, send (cache already updated)

CUSTOMTRANSPORT: to use a custom transport, change this.targetStream to use your custom transport.

Resend all debugger state for new client clear client state cache

Parse arguments.

not negative zero

stats and dumping

map from (merged) command name to number

stats for current debug connection

"request" can be a string or "true"

Use a PassThrough stream to debug dump and get stats for output messages. Simply write outgoing data to both the targetStream and this passthrough separately.

object

* Debugger output formatting

Read final, effective breakpoints from the target

cached

null

4-byte string

String map for commands (debug dumping). A single map works (instead of separate maps for each direction) because command numbers don't currently overlap. So merge the YAML metadata.

nop

lightfunc

false

stream is closed/broken, don't parse anymore

trailing '"' intentionally missing

heapptr

Explicit rate limiter because this is a source of a lot of traffic.

* Minimal debug web console for Duktape command line tool * * See debugger/README.rst. * * The web UI socket.io communication can easily become a bottleneck and * it's important to ensure that the web UI remains responsive. Basic rate * limiting mechanisms (token buckets, suppressing identical messages, etc) * are used here now. Ideally the web UI would pull data on its own terms * which would provide natural rate limiting. * * Promises are used to structure callback chains. * * https://github.com/petkaantonov/bluebird * https://github.com/petkaantonov/bluebird/blob/master/API.md * https://github.com/petkaantonov/bluebird/wiki/Promise-anti-patterns

Pretty print a debugger message given as an array of parsed dvalues. * Result should be a pure ASCII one-liner.

Constants

Not possible in practice.

* Express setup and socket.io

Represent non-integers as IEEE double dvalues

UTF-8

Ignore unknown notify messages

console.log(msg);

0x60...0x7f: strings with length 0-31

Delete matching breakpoints in reverse order so that indices remain valid. We do this for all operations so that duplicates are eliminated if present.

0xc0...0xff: integers 0-16383

close previous target connection

4-byte buffer

inform web UI

XXX: signal success to UI?

Bytecode opcode/extraop metadata

Token bucket rate limiter for a given callback. Calling code calls * trigger() to request 'cb' to be called, and the rate limiter ensures * that 'cb' is not called too often.

Poll various state items when running

pc is preincremented before adding

cache to avoid resending identical data

Here utf8.decode() is better than decoding using NodeJS buffer operations because we want strict UTF-8 interpretation.

Right now the implementation is setInterval-based, but could also be made timerless. There are so few rate limited resources that this doesn't matter in practice.

Value could be a Node.js buffer directly, but we prefer all dvalues to be JSON compatible

this.targetStream.destroy();

nop

Don't add a 'value' key to numbers.

preformatted dvalues

used to flag special values like undefined

no bias in LDINTX

debugger singleton current socket (or null)

Try to detach cleanly, timeout if no response

4-byte signed integer

heapptr

plain buffer

* Target binary connection handler

number (IEEE double), big endian

Encode arguments into dvalues.

disconnect JSON client too (if not already disconnected)

* JSON proxy server * * Accepts an incoming JSON proxy client and connects to a debug target, * tying the two connections together. Supports both a single connection * and a persistent mode.

true

truncate higher bits

* JSON connection handler

Represented signed 32-bit integers as plain integers. Debugger code expects this for all fields that are not duk_tval representations (e.g. command numbers and such).

Not possible in practice.

* Main

indicate 'v' is actually set

2-byte string

Once we're connected to the target, start read both binary and JSON input. We don't want to read JSON input before this so that we can always translate incoming messages to dvalues and write them out without queueing. Any pending JSON messages will be queued by the OS instead.

Generic handshake format: only relies on initial version field.

undefined

0x80...0xbf: integers 0-63

pointer

0x60...0x7f: strings with length 0-31

Represent non-integers as IEEE double dvalues.

0xc0...0xff: integers 0-16383

Trial parse dvalue(s) and debug messages.

default logger log.l = 0; // enable debug and trace logging

4-byte buffer

2-byte buffer

Parse message type, determine initial marker for binary message.

Note that typeof null === 'object'.

* Config

* Misc helpers

Feed the data one byte at a time when torture testing.

When this is invoked the proxy connection and the target connection have both been closed.

Add an EOM, and write out the dvalues to the debug target.

* Detect missing 'var' declarations

whole

not negative zero

Receive data into 'incoming', resizing as necessary.

explicit flag for e.g. v === undefined

disconnect target too (if not already disconnected)

make a copy, ensuring there's no slice offset get underlying plain buffer

Trial parse JSON message(s).

This is still pretty awkward in Duktape 1.4.x. Argument may be a "slice" and we want a copy of the slice (not the full underlying buffer).

Prevent new bindings on global object. This detects missing 'var' declarations, e.g. "x = 123;" in a function without declaring it.

object

lightfunc

skip dukluv and script name

null

More detailed v1 handshake line.

4-byte string

don't register any sockets/timers etc to exit

Trial parse handshake unless done.

false

!/usr/bin/env python2 Merge debugger YAML metadata files and output a merged JSON metadata file.

#exec-status

#center-area

#part-middle

#part-footer

<span id="source-filename">?</span>

No source loaded

#about-dialog

#part-header

#left-area

#right-area

Eval may take seconds to complete so indicate it is pending.

Bytecode dialog highlight

If previous update is pending, abort and start a new one.

http://diveintohtml5.info/storage.html

Note: loadedFileName can be either from target or from server, but they must match exactly. We could do a loose match here, but exact matches are needed for proper breakpoint handling anyway.

Remove eval button "pulsating" glow when we get a result

may be null

Remove pending highlight once we're no longer running.

Update the "console" output based on lines sent by the server. The server rate limits these updates to keep the browser load under control. Even better would be for the client to pull this (and other stuff) on its own.

* Duktape debugger web client * * Talks to the NodeJS server using socket.io. * * http://unixpapa.com/js/key.html

If we just became paused, check for eval watch

Make copies of the requested file/line so that we have the proper values in case they've changed.

* UI update handling when exec-status update arrives

Active breakpoints follow

Exact match is required.

returns a Manager

Update interval for custom source highlighting.

Duktape now restricts execution status updates quite effectively so there's no need to rate limit UI updates now.

puff slide, puff

onclick handler for exec status text

Source is updated periodically. Other code can also call doSourceUpdate() directly if an immediate update is needed.

* AJAX request handling to fetch source files

If we're executing the file shown, highlight current line

Make source window grey when running for a longer time, use a small delay to avoid flashing grey when stepping.

Remove previously added custom classes

Not really interesting in the UI $('#server-info').text(new Date() + ': ' + JSON.stringify(msg));

Not 100% reliable if callstack has several functions of the same name

If no-one requested us to scroll to a specific line, finish.

Update buttons

http://stackoverflow.com/questions/14918787/jquery-scroll-to-bottom-of-div-even-after-it-updates Stop queued animations so that we always scroll quickly to bottom

First line is special

AJAX request for the source.

* Initialization

About dialog, shown automatically on first startup.

Enter handling for eval input https://forum.jquery.com/topic/bind-html-input-to-enter-key-keypress

Eval watch handling

We'd like to window.close() here but can't (not allowed from scripts). Alert is the next best thing.

float

Bytecode dialog

Force source view to match currFileName only when running or when just became paused (from running or detached).

nop

Force line update (scrollTop) only when running or just became paused. Otherwise let user browse and scroll source files freely.

Not worth alerting about because source fetch errors happen all the time, e.g. for dynamically evaluated code.

Execution state previous execution state ('paused', 'running', etc) previous debugger attached state (true, false, null) current filename being executed current function name being executed current line being executed current bytecode PC being executed current execution state ('paused', 'running', 'detached', etc) current debugger attached state (true or false) current local variables current callstack (from top to bottom) current breakpoints timestamp when last started running (if running) (used to grey out the source file if running for long enough)

* Source view periodic update handling

If we just started running, store a timestamp so we can grey out the source view only if we execute long enough (i.e. we're not just stepping).

* Init socket.io and add handlers

don't clear eval input

* AJAX request for fetching the source list

This is worth alerting about as the UI is somewhat unusable if we don't get a source list.

Update current execution state

Add breakpoints

* Helpers

Pause may take seconds to complete so indicate it is pending.

This must fit into the smallest pool entry.

Define to enable some debug printfs.

Use 'st' as udata.

Still fits, no shrink support.

'ptr' cannot be NULL.

DUK_ALLOC_HYBRID_H_INCLUDED

Handle the ptr-NULL vs. size-zero cases explicitly to minimize * platform assumptions. You can get away with much less in specific * well-behaving environments.

Suppress warning.

Note: ajduk doesn't log oldsize (uses -1 instead)

A ptr/NULL/FAIL size F ptr/NULL size R ptr/NULL oldsize ptr/NULL/FAIL newsize

Handle the ptr-NULL vs. size-zero cases explicitly to minimize * platform assumptions. You can get away with much less in specific * well-behaving environments.

Suppress warning.

Force address change on every realloc.

DUK_ALLOC_TORTURE_H_INCLUDED

* Enter interactive mode if options indicate it

[ ... bytecode_filename src_data src_len filename ]

* Main

Example of sending an application specific debugger notification.

'p' points to a NUL (p == p_end) or a period.

avoid SIGPIPE killing process

Full completion, add a period, e.g. input 'Math' -> 'Math.'.

Here we know the eval arg exists but check anyway

DUK_CMDLINE_RLIMIT

* Misc helpers

A virtual '/tmp' exists by default: * https://gist.github.com/evanw/e6be28094f34451bd5bd#file-temp-js-L3806-L3809

DUK_CMDLINE_LINENOISE_COMPLETION

Callback should avoid errors for now, so use * duk_check_stack() rather than duk_require_stack().

Manual test for bytecode dump/load cycle: dump and load before * execution. Enable manually, then run "make qecmatest" for a * reasonably good coverage of different functions and programs.

try { FS.unmount("/"); } catch (e) { console.log("Failed to unmount default '/' MEMFS mount: " + e); }

original, including partial last component

Ensure socket is closed even when detach is initiated by Duktape * rather than debug client.

* Minimal Linenoise completion support

caller coerces

[ ... bytecode_filename src_data src_len function ]

Optional bytecode dump.

Print error objects with a stack trace specially. * Note that getting the stack trace may throw an error * so this also needs to be safe call wrapped.

* Duktape heap lifecycle

Manual test for duk_debugger_cooperate()

'idx_obj' points to the object matching the last * full component, use [p_curr,p[ as a filter for * that object.

Running stdin like a full file (reading all lines before * compiling) is useful with emduk: * cat test.js | ./emduk --run-stdin

should never happen, but just in case

Catches e.g. 'foo..bar' -> we want 'bar' only.

Print error to stderr and pop error.

* Signal handling setup

~2 GB

Partial ends in a period, e.g. 'Math.' -> complete all Math properties.

fatal_handler

Read until EOF, avoid fseek/stat because it won't work with stdin.

global

Defined in duk_cmdline_ajduk.c or alljoyn.js headers.

'p' will either be p_start - 1 (ran out of buffer) or point to * the first offending character.

nrets

In non-interactive mode, success results are not written at all. * It is important that the result value is not string coerced, * as the string coercion may cause an error in some cases.

* In interactive mode, write to stdout so output won't * interleave as easily. * * NOTE: the ToString() coercion may fail in some cases; * for instance, if you evaluate: * * ( {valueOf: function() {return {}}, * toString: function() {return {}}}); * * The error is: * * TypeError: failed to coerce with [[DefaultValue]] * duk_api.c:1420 * * These are handled now by the caller which also has stack * trace printing support. User code can print out errors * safely using duk_safe_to_string().

DUK_CMDLINE_FILEIO

* Command line execution tool. Useful for test cases and manual testing. * * To enable linenoise and other fancy stuff, compile with -DDUK_CMDLINE_FANCY. * It is not the default to maximize portability. You can also compile in * support for example allocators, grep for DUK_CMDLINE_*.

get_value

nret

for properties of plain strings etc

Not an Error instance, don't read "stack".

'this' binding

Source code.

DUK_CMDLINE_SIGNAL

skip code

* Simple file read/write bindings

* Usage

'p' now points to a string of the form 'foo.bar.quux'. Look up * all the components except the last; treat the last component as * a partial name which is used as a filter for the previous full * component. All lookups are from the global object now.

p_curr == p_end allowed on purpose, to handle 'Math.' for example.

For automatic reattach testing.

Not found.

Use duk_compile_lstring_filename() variant which avoids interning * the source code. This only really matters for low memory environments.

heap_udata: ignored by AjsHeap, use as marker

* Memory limit

fall thru

original, e.g. 'Math.'

DUK_CMDLINE_LINENOISE

* Execute from file handle etc

* Create heap

completion to last component

128 MB

signal(SIGPIPE, SIG_IGN);

EMSCRIPTEN

Bytecode.

in interactive mode, write to stdout

Try to use NODEFS to provide access to local files. Mount the * CWD as /working, and then prepend "/working/" to relative native * paths in file calls to get something that works reasonably for * relative paths. Emscripten doesn't support replacing virtual * "/" with host "/" (the default MEMFS at "/" can't be unmounted) * but we can mount "/tmp" as host "/tmp" to allow testcase runs. * * https://kripken.github.io/emscripten-site/docs/api_reference/Filesystem-API.html#filesystem-api-nodefs * https://github.com/kripken/emscripten/blob/master/tests/fs/test_nodefs_rw.c

suppress warning

try { FS.mkdir("/tmp"); } catch (e) { console.log("Failed to create virtual /tmp: " + e); }

Should never happen, just in case.

* Execute any argument file(s)

* Parse options

an error 'taints' the execution

At the moment it's not possible to replace the default MEMFS mounted at '/': * https://github.com/kripken/emscripten/issues/2040 * https://github.com/kripken/emscripten/blob/incoming/src/library_fs.js#L1341-L1358

nargs

Helper define to enable a feature set; can also use separate defines.

Last component is partial, complete.

Ignore array index keys: usually not desirable, and would * also require ['0'] quoting.

Scan backwards for a maximal string which looks like a property * chain (e.g. foo.bar.quux).

skip filename

This extern declaration is provided by duktape.h, array provided by duktape.c.

heapConfig

Enable heap dumps

duk_heap, with heap ptr compression, ROM strings+objects

...

Scan ROM pointer range for faster detection of "is 'p' a ROM pointer" * later on.

heapSz

numPools

* Not present yet, check if we have space. Again, be careful to * ensure there is space for a NUL following the input data.

Linear scan. An actual implementation would need some acceleration * structure, e.g. select a sublist based on first character. * * NOTE: input string (behind 'ptr' with 'len' bytes) DOES NOT have a * trailing NUL character. Any strings returned from this function * MUST have a trailing NUL character.

* 'ajduk' specific functionality, examples for low memory techniques

Pointer compression with ROM strings/objects: * * For now, use DUK_USE_ROM_OBJECTS to signal the need for compressed ROM * pointers. DUK_USE_ROM_PTRCOMP_FIRST is provided for the ROM pointer * compression range minimum to avoid duplication in user code.

to avoid empty source file

Ensure that we always get the heap_udata given in heap creation. * (Useful for Duktape development, not needed for user programs.)

AjsHeap.dump(), allows Ecmascript code to dump heap status at suitable * points.

heapNum

protected call not yet running

Ensure that we always get the heap_udata given in heap creation.

heap

* These strings are from util/duk_meta_to_strarray.py

duk_heap, with heap ptr compression, RAM strings+objects

This is a blind lookup, could check index validity. * Duktape should never decompress a pointer which would * be out-of-bounds here.

* These strings are manually added, and would be gathered in some * application specific manner.

* Example pointer compression functions. * * 'base' is chosen so that no non-NULL pointer results in a zero result * which is reserved for NULL pointers.

* There is space, add the string to our collection, being careful * to append the NUL.

DUK_CMDLINE_AJSHEAP

until_nul

We should really never be here: Duktape should only be * compressing pointers which are in the ROM compressed * pointers list, which are known at 'make dist' time. * We go on, causing a pointer compression error.

* Simplified example of an external strings strategy where a set of strings * is gathered during application compile time and baked into the application * binary. * * Duktape built-in strings are available from duk_build_meta.json, see * util/duk_meta_to_strarray.py. There may also be a lot of application * specific strings, e.g. those used by application specific APIs. These * must be gathered through some other means, see e.g. util/scan_strings.py.

* Execution timeout example

See userdata discussion in ajsheap_enc16().

duk_hthread, with heap ptr compression, ROM strings+objects

numHeaps

* Helpers

seconds

* Convert an 8-bit input string (e.g. ISO-8859-1) into CESU-8. * Calling code supplies the "code page" as a 256-entry array of * codepoints for the conversion. * * This is useful when input data is in non-UTF-8 format and must * be converted at runtime, e.g. when compiling non-UTF-8 source * code. Another alternative is to use e.g. iconv.

Temporary buffer length wraps.

max expansion is 1 input byte -> 3 output bytes

Decode an 8-bit string using 'codepage' into Unicode codepoints and * re-encode into CESU-8. Codepage argument must point to a 256-entry * table. Only supports BMP (codepoints U+0000 to U+FFFF).

[ ... tmp res ]

In CESU-8 all codepoints in [0x0000,0xFFFF] are * allowed, including surrogates.

DUK_CODEPAGE_CONV_H_INCLUDED

http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP1252.TXT

Example: compile and run test source encoded in Windows codepage 1252.

undefined

Exercise all 3 byte lengths: any ASCII character is 1 byte, 0xFC maps to * U+00FC which is 2 bytes, and 0x80 maps to U+20AC which is 3 bytes.

* Same as above, but if the exception inherits from std::exception, it's * "what()" will be included in the error message.

* If you let your own C++ exceptions propagate out of a Duktape/C function * it will be caught by Duktape and considered a programming error. Duktape * will catch the exception and convert it to a Duktape error. * * This may be allowed in a later version once all the implications have been * worked out.

ERROR: exception propagated to Duktape

* Example class with a destructor

suppress warning

* Example of how to use DUK_USE_CPP_EXCEPTIONS to support automatic * variables (e.g. destructor calls) in Duktape/C functions. * * Compile with -DDUK_OPT_CPP_EXCEPTIONS: * * $ g++ -otest -DDUK_OPT_CPP_EXCEPTIONS -I<duktape_dist>/src/ \ * <duktape_dist>/src/duktape.c cpp_exceptions.cpp -lm * * or ensure duk_config.h has DUK_USE_CPP_EXCEPTIONS enabled using * genconfig. When executed you should see something like: * * $ ./test * my_class instance created * my_class instance destroyed <== destructor gets called * --> rc=1 (SyntaxError: parse error (line 1)) * [...] * * Duktape uses a custom exception class (duk_internal_exception) which * doesn't inherit from any base class, so that catching any base classes * in user code won't accidentally catch exceptions thrown by Duktape.

* You can use C++ exceptions inside Duktape/C functions for your own * purposes but you should catch them before they propagate to Duktape.

* SyntaxError caused by eval exits Duktape/C function but destructors * are executed.

* Same as above, but if the exception inherits from std::exception with * a NULL what(). Duktape will describe the error as 'unknown' if so.

Handshake line is available for caller for the * duration of the callback, and must not be freed * by the caller.

Too small, resize.

just in case, if dvalues changed something

mixed endian (arm)

Define to enable error prints to stderr.

0x80 ... 0xbf

Handshake line is returned as a dvalue for convenience; it's * not actually a part of the dvalue phase of the protocol.

Too big, resize so that we reclaim memory if we have just * received a large string/buffer value.

little endian

0x00 ... 0x1f

never here

0x60 ... 0x7f

Caller must provide a buffer at least DUK_DVALUE_TOSTRING_BUFLEN in size.

Harmless warning on some platforms (re: range)

Alloc size is len + 1 so that a NUL terminator is always * guaranteed which is convenient, e.g. you can printf() the * value safely.

big endian

Integers are network endian, read back into host format.

Portable IEEE double byteswap. Relies on runtime detection of * host endianness.

Integers are written in network endian format.

IEEE doubles are network endian, read back into host format.

32 hex encoded or \xXX escaped bytes, possible "...", NUL

* Dvalue transport handling

Integers are network endian, read back into host format in * a portable manner.

0xc0 ... 0xff

* Dvalue handling

end switch

* Duktape callbacks

Portable sign handling, doesn't assume 'int' is exactly 32 bits * like a direct cast would.

Trial parse handshake line or dvalue(s).

IEEE doubles are written in network endian format.

Must cooperate until user callback provides data. From * Duktape's perspective we MUST block until data is received.

mixed endian

0x20 ... 0x5f

Append data.

When read_offset is large enough, "rebase" buffer by deleting already * read data and updating offsets.

big endian: ok as is

Convert argument dvalue into Duktape debug protocol format. * Literal constants are used here for the debug protocol, * e.g. initial byte 0x02 is REP, see doc/debugger.rst.

tolerates NULL

d: ieee double

sending towards Duktape (duktape read callback)

Buffer size needed by duk_dvalue_to_string().

buf: buffer data, len: buffer length

DUK_TRANS_DVALUE_H_INCLUDED

struct duk_dvalue 'tag' values, note that these have nothing to do with * Duktape debug protocol inital byte. Struct fields used with the type * are noted next to the define.

i: class number, buf: pointer data, len: pointer length

i: 32-bit signed integer

buf: pointer data, len: pointer length

Sending dvalues towards Duktape.

Duktape debug callbacks provided by the transport.

receiving from Duktape (duktape write callback)

buf: string data, len: string length

Could use a union for the value but the gain would be relatively small.

no fields

Initializing and freeing the transport context.

Dvalue handling.

i: lightfunc flags, buf: pointer data, len: pointer length

Attach debugger; this will fail with a fatal error here unless * debugger support is compiled in. To fail more gracefully, call * this under a duk_safe_call() to catch the error.

DumpHeap

fake ptr len

The Duktape handshake line is given in 'line' (without LF). * The 'line' argument can be accessed for the duration of the * callback (read only). Don't free 'line' here, the transport * handles that.

medium, >= 32 chars

Evaluate simple test code, callbacks will "step over" until end. * * The test code here is just for exercising the debug transport. * The 'evalMe' variable is evaluated (using debugger command Eval) * before every step to force different dvalues to be carried over * the transport.

duk_trans_dvalue_send_req_cmd() sends a REQ dvalue followed by * an integer dvalue (command) for convenience.

classnum

Detached call forwarded as is.

0x14 = StepOver

* Example program using the dvalue debug transport.

long buffer, >= 65536 chars

TriggerStatus

suppress warning

Here a normal debug client would wait for dvalues until an EOM * dvalue was received (which completes a debug message). The * debug message would then be handled, possibly causing UI changes * and/or causing debug commands to be sent to Duktape. * * The callback is responsible for eventually freeing the dvalue. * Here we free it immediately, but an actual client would probably * gather dvalues into an array or linked list to handle when the * debug message was complete.

Duktape is not blocked; you can cooperate with e.g. a user * interface here and send dvalues to Duktape, but don't block.

Also send a dummy TriggerStatus request with trailing dvalues * ignored by Duktape; Duktape will parse the dvalues to be able to * skip them, so that the dvalue encoding is exercised.

0x1e = Eval

short, <= 31 chars

Duktape is blocked on a read and won't continue until debug * command(s) are sent. * * Normally you'd enter your own event loop here, and process * events until something needs to be sent to Duktape. For * example, the user might press a "Step over" button in the * UI which would cause dvalues to be sent. You can then * return from this callback. * * The code below sends some example messages for testing the * dvalue handling of the transport. * * If you create dvalues manually and send them using * duk_trans_dvalue_send(), you must free the dvalues after * the send call returns using duk_dvalue_free().

lf_flags

DUK_TRANS_SOCKET_H_INCLUDED

Duktape debug transport callback: (possibly partial) read.

This shouldn't happen.

should never happen

This TCP transport requires no write flush handling so ignore. * You can also pass a NULL to duk_debugger_attach() and not * implement this callback at all.

* Example debug transport using a Linux/Unix TCP socket * * Provides a TCP server socket which a debug client can connect to. * After that data is just passed through.

This TCP transport requires no read flush handling so ignore. * You can also pass a NULL to duk_debugger_attach() and not * implement this callback at all.

backlog

In a production quality implementation there would be a sanity * timeout here to recover from "black hole" disconnects.

Duktape debug transport callback: (possibly partial) write.

Write flush. If the transport combines multiple writes * before actually sending, a write flush is an indication * to write out any pending bytes: Duktape may not be doing * any more writes on this occasion.

* Transport init and finish

* Duktape callbacks

nothing to read

also returns 0, which is correct

Read flush: Duktape may not be making any more read calls at this * time. If the transport maintains a receive window, it can use a * read flush as a signal to update the window status to the remote * peer. A read flush is guaranteed to occur before Duktape stops * reading for a while; it may occur in other situations as well so * it's not a 100% reliable indication.

something to read

Duktape debug transport callback: (possibly partial) read.

This shouldn't happen.

This TCP transport requires no write flush handling so ignore. * You can also pass a NULL to duk_debugger_attach() and not * implement this callback at all.

This TCP transport requires no read flush handling so ignore. * You can also pass a NULL to duk_debugger_attach() and not * implement this callback at all.

In a production quality implementation there would be a sanity * timeout here to recover from "black hole" disconnects.

Duktape debug transport callback: (possibly partial) write.

Write flush. If the transport combines multiple writes * before actually sending, a write flush is an indication * to write out any pending bytes: Duktape may not be doing * any more writes on this occasion.

* Transport init and finish

* Example debug transport using a Windows TCP socket * * Provides a TCP server socket which a debug client can connect to. * After that data is just passed through. * * https://msdn.microsoft.com/en-us/library/windows/desktop/ms737593(v=vs.85).aspx * * Compiling 'duk' with debugger support using MSVC (Visual Studio): * * > cl /W3 /O2 /Feduk.exe * /DDUK_OPT_DEBUGGER_SUPPORT /DDUK_OPT_INTERRUPT_COUNTER * /DDUK_CMDLINE_DEBUGGER_SUPPORT * /Iexamples\debug-trans-socket /Isrc * examples\cmdline\duk_cmdline.c * examples\debug-trans-socket\duk_trans_socket_windows.c * src\duktape.c * * With MinGW: * * $ gcc -oduk.exe -Wall -O2 \ * -DDUK_OPT_DEBUGGER_SUPPORT -DDUK_OPT_INTERRUPT_COUNTER \ * -DDUK_CMDLINE_DEBUGGER_SUPPORT \ * -Iexamples/debug-trans-socket -Isrc \ * examples/cmdline/duk_cmdline.c \ * examples/debug-trans-socket/duk_trans_socket_windows.c \ * src/duktape.c -lm -lws2_32

* Duktape callbacks

also returns 0, which is correct

nothing to read

never here

Read flush: Duktape may not be making any more read calls at this * time. If the transport maintains a receive window, it can use a * read flush as a signal to update the window status to the remote * peer. A read flush is guaranteed to occur before Duktape stops * reading for a while; it may occur in other situations as well so * it's not a 100% reliable indication.

something to read

Return a fixed time here as a dummy example.

* Dummy Date provider * * There are two minimally required macros which you must provide in * duk_config.h: * * extern duk_double_t dummy_get_now(void); * * #define DUK_USE_DATE_GET_NOW(ctx) dummy_get_now() * #define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d) 0 * * Note that since the providers are macros, you don't need to use * all arguments. Similarly, you can "return" fixed values as * constants. Above, local timezone offset is always zero i.e. * we're always in UTC. * * You can also provide optional macros to parse and format timestamps * in a platform specific format. If not provided, Duktape will use * ISO 8601 only (which is often good enough).

* Very simple example program for evaluating expressions from * command line

nargs

nrets

* A few basic tests

XXX: or t->target + t->delay?

ignore errors for now -> [ ... stash eventTimers ]

not found, append to list

Initialize global stash 'eventTimers'.

Update timer_count.

Misc

-> [ ... ]

-> [ ... stash eventTimers retval ]

One-shot timer (always removed) or removed by user callback.

Finally, register the callback to the global stash 'eventTimers' object.

* Determine poll() timeout (as close to poll() as possible as * the wait is relative).

Interval timer, not removed by user callback. Queue back to * timer list and bubble to its final sorted position.

deleted, perhaps by previous callback

Timer is now at the last position; use swaps to "bubble" it to its * correct sorted position.

* If exit has been requested, exit without running further * callbacks.

last timer at timer_count - 1

Zero last element for clarity.

Socket poll state.

[ ... stash eventTimers ]

error

* Compact poll list by removing pollfds with fd == 0.

Set global 'EventLoop'.

eventTimers[timer_id] = callback

Last timer expires first (list is always kept sorted).

-> [ ... stash eventTimers func ]

delay/interval

oneshot=1 (setTimeout), repeated=0 (setInterval)

The callback associated with the timer is held in the "global stash", * in <stash>.eventTimers[String(id)]. The references must be deleted * when a timer struct is deleted.

Get Javascript compatible 'now' timestamp (millisecs since 1970).

events == 0 means stop listening to the FD

-> [ timer_id stash eventTimers ]

* Expire timers.

Shift elements downwards to keep the timer list dense * (no need if last element).

* If exit requested, bail out as fast as possible.

't' expires later than 't-1', so swap them and repeat.

Timer to bubble is at index i, timer to compare to is * at i-1 (both guaranteed to exist).

Return timer id.

Bubble last timer on timer list backwards until it has been moved to * its proper sorted position (based on 'target' time).

next target time

i = input index * j = output index (initially same as i)

The C state is now up-to-date, but we still need to delete * the timer callback state from the global 'stash'.

'rc' fds active

clamping ensures that fits

* Expired timer(s) still exist?

timeout

* Move the timer to 'expiring' for the duration of the callback. * Mark a one-shot timer deleted, compute a new target for an interval.

* Call timer callback. The callback can operate on the timer list: * add new timers, remove timers. The callback can even remove the * expired timer whose callback we're calling. However, because the * timer being expired has been moved to 'timer_expiring', we don't * need to worry about the timer's offset changing on the timer list.

if timeout, no need to check pollfd

The Ecmascript poll handler is passed through EventLoop.fdPollHandler * which c_eventloop.js sets before we come here.

indexes: * 0 = function (callback) * 1 = delay * 2 = boolean: oneshot

-> [ func delay oneshot stash eventTimers ]

nargs

* Poll for activity or timeout.

copy only if indices have diverged

timer has been requested for removal

-> [ global EventLoop fdPollHandler ]

Because a user callback can mutate the timer list (by adding or deleting * a timer), we expire one timer and then rescan from the end again. There * is a sanity limit on how many times we do this per expiry round.

keep output index the same

numeric ID (returned from e.g. setTimeout); zero if unused

Should never happen, so return whatever.

delete eventTimers[timer_id]

't' expires earlier than (or same time as) 't-1', so we're done.

indexes: * 0 = timer id

print('unexpected revents, close fd');

no size control now print('READ', Duktape.enc('jx', data));

* C eventloop example (c_eventloop.c). * * Ecmascript code to initialize the exposed API (setTimeout() etc) when * using the C eventloop. * * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Timers

This simple example doesn't have support for write blocking / draining

Connected

print('ACCEPT:', Duktape.enc('jx', acc_res));

Special case: callback arguments are provided. [ arg1, arg2, ... ] [ global(this), arg1, arg2, ... ]

print('activity on fd', fd, 'revents', revents);

* Timer API

retval ignored

print('UNKNOWN');

Legacy case: callback is a string.

oneshot

Normal case: callback given as a function without arguments.

Math.exp(0)...Math.exp(8) is an uneven distribution between 1...~2980.

Here the inserts take a lot of time because the underlying timer manager * data structure has O(n) insertion performance.

* Test using timers and intervals with curses.

* Pure Ecmascript eventloop example. * * Timer state handling is inefficient in this trivial example. Timers are * kept in an array sorted by their expiry time which works well for expiring * timers, but has O(n) insertion performance. A better implementation would * use a heap or some other efficient structure for managing timers so that * all operations (insert, remove, get nearest timer) have good performance. * * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Timers

Remove the timer from the active list and process it. The user callback may add new timers which is not a problem. The callback may also delete timers which is not a problem unless the timer being deleted is the timer whose callback we're running; this is why the timer is recorded in this.expiring so that clearTimeout() and clearInterval() can detect this situation.

sockets fd -> callback fd -> callback fd -> callback

If the timer was one-shot, it's marked 'removed'. If the user callback requested deletion for the timer, it's also marked 'removed'. If the timer is an interval (and is not marked removed), insert it back into the timer list.

this.dumpState();

Timer has expired and we're processing its callback. User callback has requested timer deletion. Mark removed, so that the timer is not reinserted back into the active list. This is actually a common case because an interval may very well cancel itself.

Special case: callback arguments are provided. [ arg1, arg2, ... ] [ global(this), arg1, arg2, ... ]

This simple example doesn't have support for write blocking / draining

no such ID, ignore

print('zero read for fd ' + fd + ', closing forcibly'); ignore result

print('UNKNOWN');

Legacy case: callback is a string.

timers active timers, sorted (nearest expiry last) set to timer being expired (needs special handling in clearTimeout/clearInterval)

no size control now print('READ', Duktape.enc('jx', data));

print('revents ' + t.revents + ' for fd ' + fd + ', closing forcibly'); ignore result

misc

print('ACCEPT:', Duktape.enc('jx', acc_res));

* Create poll socket list. This is a very naive approach. * On Linux, one could use e.g. epoll() and manage socket lists * incrementally.

start

deleteCount

* Find 'i' such that we want to insert *after* timers[i] at index i+1. * If no such timer, for-loop terminates with i-1, and we insert at -1+1=0.

print('exit requested, exit');

Remove timer/interval with a timer ID. The timer/interval can reside either on the active list or it may be an expired timer (this.expiring) whose user callback we're running when this function gets called.

Get timer with lowest expiry time. Since the active timers list is sorted, it's always the last timer.

* Wait timeout for timer closest to expiry. Since the poll * timeout is relative, get this as close to poll() as possible.

print(new Date(), 'poll_set OUT:', Duktape.enc('jx', poll_set));

* Do the actual poll.

* Timer API * * These interface with the singleton EventLoop.

print('UNKNOWN POLLOUT');

Timers to expire?

* Exit check (may be requested by a user callback)

insert after 't', to index i+1

* Event loop * * Timers are sorted by 'target' property which indicates expiry time of * the timer. The timer expiring next is last in the array, so that * removals happen at the end, and inserts for timers expiring in the * near future displace as few elements in the array as possible.

print(new Date(), 'poll_set IN:', Duktape.enc('jx', poll_set));

* Here we must be careful with mutations: user callback may add and * delete an arbitrary number of timers. * * Current solution is simple: check whether the timer at the end of * the list has expired. If not, we're done. If it has expired, * remove it from the active list, record it in this.expiring, and call * the user callback. If user code deletes the this.expiring timer, * there is special handling which just marks the timer deleted so * it won't get inserted back into the active list. * * This process is repeated at most maxExpirys times to ensure we don't * get stuck forever; user code could in principle add more and more * already expired timers.

custom call

* Process expired timers.

* Process all sockets so that nothing is left unhandled for the * next round.

flag for removal

Timer has not expired, and no other timer could have expired either because the list is sorted.

Reinsert interval timer to correct sorted position. The timer must be an interval timer because one-shot timers are marked 'removed' above.

Eat errors silently. When resizing curses window an EINTR happens now.

Normal case: callback given as a function without arguments.

Set global 'FileIo'.

* File I/O binding example.

fall thru

nargs

nrets

[ ... global func ]

Duktape/C function, safe called

nret

Start a zero timer which will call _USERCODE from within * the event loop.

Finally, launch eventloop. This call only returns after the * eventloop terminates.

signal(SIGPIPE, SIG_IGN);

Compile input and place it into global _USERCODE

Print error to stderr and pop error.

NO_SIGNAL

* Main for evloop command line tool. * * Runs a given script from file or stdin inside an eventloop. The * script can then access setTimeout() etc.

Set global 'Ncurses'.

XXX: no screen management now

[retarr]

-> [... retarr key]

Linux 2.6.17 and upwards, requires _GNU_SOURCE etc, not added * now because we don't use it.

-> [... retarr fd]

enum_flags

leave enum on stack

* C wrapper for poll().

update revents

Set global 'Poll' with functions and constants.

-> [... enum key val events]

-> [... enum key val]

-> [... enum]

-> [... retarr val "revents" fds[i].revents]

[... enum key]

rc = ppoll(fds, n, &ts, NULL);

-> [... enum key key]

-> [... retarr val]

uppercase

ensure we get a plain buffer

Handle socket data carefully: if you convert it to a string, it may not be valid UTF-8 etc. Here we operate on the data directly in the buffer.

backlog

Set global 'Socket'.

MSG_NOSIGNAL: avoid SIGPIPE

* TCP sockets binding example.

fib.js

Pure Ecmascript version of low level helper

Check 'val' for primality

prime.js

Select available helper at load time

Find primes below one million ending in '9999'.

primecheck.c

nargs

ignore result

process.js

nargs

index

processlines.c

pop result/error

ignore result

uppercase.c

We're going to need 'sz' additional entries on the stack.

one return value

* Very simple example program

pop global

#args

suppress warning

pop eval result

nargs

nrets

-1 for filename

-> [ ... source filename ]

nrets

* Main

* Setup sandbox

Handle the ptr-NULL vs. size-zero cases explicitly to minimize * platform assumptions. You can get away with much less in specific * well-behaving environments.

must not return

256kB sandbox

* Sandboxing example * * Uses custom memory allocation functions which keep track of total amount * of memory allocated, imposing a maximum total allocation size.

-> [ ... filename source ]

* Sandbox setup and test

Should be zero.

Suppress warning.

nargs

flags

Compile as program

* Memory allocator which backs to standard library memory functions but * keeps a small header to track current allocation size. * * Many other sandbox allocation models are useful, e.g. preallocated pools.

* Execute code from specified file

* Mandelbrot example: * * $ ./duk mandel.js * [...]

z -> z^2 + c * -> (xx+i*yy)^2 + (x0+i*y0) * -> xx*xx+i*2*xx*yy-yy*yy + x0 + i*y0 * -> (xx*xx - yy*yy + x0) + i*(2*xx*yy + y0)

xx^2 + yy^2 >= 4.0

capture in closure in case changed later

* Minimal console.log() polyfill

nop

* Ensure Error .fileName, .lineNumber, and .stack are not directly writable, * but can be written using Object.defineProperty(). This matches Duktape * 1.3.0 and prior. * * See: https://github.com/svaarala/duktape/pull/390.

already non-writable

already writable

* Ensure Error .fileName, .lineNumber, and .stack are directly writable * without having to use Object.defineProperty(). This matches Duktape * 1.4.0 behavior. * * See: https://github.com/svaarala/duktape/pull/390.

tag for unpacked duk_tval

tag for packed duk_tval

internal tag is fastint

public type is DUK_TYPE_NUMBER

* Helper to check if a number is internally represented as a fastint: * * if (Duktape.isFastint(x)) { * print('fastint'); * } else { * print('not a fastint (or not a number)'); * } * * NOTE: This helper depends on the internal tag numbering (defined in * duk_tval.h) which is both version specific and depends on whether * duk_tval is packed or not.

Tag number depends on duk_tval packing.

null or undefined

enumerable own keys

* Object.assign(), described in E6 Section 19.1.2.1 * * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-object.assign

* Object.prototype.__defineGetter__ polyfill

* Object.prototype.__defineSetter__ polyfill

This should not really happen, but would indicate x64.

Emscripten (provided explicitly by user), improve if possible

Both MinGW and MSVC have a 64-bit type.

* Platform autodetection

--- TinyC ---

mint clib is missing these

SuperH

--- x64 ---

MSVC does not have sys/param.h

--- Motorola 68k ---

since gcc-2.5

--- MIPS 64-bit ---

OpenBSD

NetBSD

Apple OSX, iOS

Cannot determine byte order; __ORDER_PDP_ENDIAN__ is related to 32-bit * integer ordering and is not relevant.

Type for public API calls.

--- Generic BSD ---

uclibc may be missing these

FreeBSD

not defined by default

--- OpenBSD ---

Cygwin

integer endianness is little on purpose

e.g. getdate_r

* Autogenerated defaults

Atari Mint

Most portable, wastes space

GCC/clang inaccurate math would break compliance and probably duk_tval, * so refuse to compile. Relax this if -ffast-math is tested to work.

--- Generic ---

VS2012+ has stdint.h, < VS2012 does not (but it's available for download).

Clang

AmigaOS. Neither AMIGA nor __amigaos__ is defined on VBCC, so user must * define 'AMIGA' manually when using VBCC.

--- GCC ---

Duktape/C function return value, platform int is enough for now to * represent 0, 1, or negative error code. Must be compatible with * assigning truth values (e.g. duk_ret_t rc = (foo == bar);).

Low memory algorithm: separate chaining using arrays, fixed size hash

__OVERRIDE_DEFINES__

http://stackoverflow.com/questions/5919996/how-to-detect-reliably-mac-os-x-ios-linux-windows-in-c-preprocessor

vbcc + AmigaOS has C99 but no inttypes.h

MSVC

* Check whether or not a packed duk_tval representation is possible. * What's basically required is that pointers are 32-bit values * (sizeof(void *) == 4). Best effort check, not always accurate. * If guess goes wrong, crashes may result; self tests also verify * the guess.

--- Linux ---

--- AmigaOS ---

BCC, assume we're on x86.

Pointer size determination based on __WORDSIZE or architecture when * that's not available.

Unsigned index variant.

External provider already defined.

Byte order varies, so rely on autodetect.

DUK_USE_UNION_INITIALIZERS: required from compilers, so no fill-in.

empty

--- MSVC ---

We're generally assuming that we're working on a platform with a 32-bit * address space. If DUK_SIZE_MAX is a typecast value (which is necessary * if SIZE_MAX is missing), the check must be avoided because the * preprocessor can't do a comparison.

64-bit constants. Since LL / ULL constants are not always available, * use computed values. These values can't be used in preprocessor * comparisons; flag them as such.

--- x86 ---

--- MIPS 32-bit ---

XXX: add feature options to force basic types from outside?

Array index values, could be exact 32 bits. * Currently no need for signed duk_arridx_t.

SIZE_MAX may be missing so use an approximate value for it.

DUK_F_BCC

Complex condition broken into separate parts.

POSIX

If not provided, use safe default for alignment.

* Date provider selection * * User may define DUK_USE_DATE_GET_NOW() etc directly, in which case we'll * rely on an external provider. If this is not done, revert to previous * behavior and use Unix/Windows built-in provider.

Cannot determine byte order.

--- Cygwin ---

!defined(DUK_USE_BYTEORDER) && defined(__BYTE_ORDER__)

More or less standard endianness predefines provided by header files. * The ARM hybrid case is detected by assuming that __FLOAT_WORD_ORDER * will be big endian, see: http://lists.mysql.com/internals/443. * On some platforms some defines may be present with an empty value which * causes comparisons to fail: https://github.com/svaarala/duktape/issues/453.

!defined(DUK_USE_BYTEORDER)

Good default is a bit arbitrary because alignment requirements * depend on target. See https://github.com/svaarala/duktape/issues/102.

--- Windows ---

User provided InitJS.

These have been tested from VS2008 onwards; may work in older VS versions * too but not enabled by default.

Error codes are represented with platform int. High bits are used * for flags and such, so 32 bits are needed.

Intermediate define for 'have inttypes.h'

build is not C99 or C++11, play it safe

GCC: test not very accurate; enable only in relatively recent builds * because of bugs in gcc-4.4 (http://lists.debian.org/debian-gcc/2010/04/msg00000.html)

Intel x86 (32-bit), x64 (64-bit) or x32 (64-bit but 32-bit pointers), * define only one of DUK_F_X86, DUK_F_X64, DUK_F_X32. * https://sites.google.com/site/x32abi/

Enabled with debug/assertions just so that any issues can be caught.

C99 or compatible